From 2a139a32e1015d3f436682da9f5423035c27218d Mon Sep 17 00:00:00 2001 From: Stefan Date: Fri, 13 Sep 2024 14:18:52 +0200 Subject: [PATCH 01/60] feat: print the feature model without cross tree constraints as pseudo-boolean constraints in .opb format --- src/main/java/de/vill/main/Example.java | 74 +++---------------- src/main/java/de/vill/model/Feature.java | 65 ++++++++++++++++ src/main/java/de/vill/model/FeatureModel.java | 7 ++ 3 files changed, 81 insertions(+), 65 deletions(-) diff --git a/src/main/java/de/vill/main/Example.java b/src/main/java/de/vill/main/Example.java index c5ba734..7bc097b 100644 --- a/src/main/java/de/vill/main/Example.java +++ b/src/main/java/de/vill/main/Example.java @@ -1,84 +1,28 @@ package de.vill.main; import de.vill.config.Configuration; -import de.vill.model.Attribute; -import de.vill.model.Feature; -import de.vill.model.FeatureModel; -import de.vill.model.Group; +import de.vill.model.*; import de.vill.model.constraint.Constraint; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; +import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Set; public class Example { public static void main(String[] args) throws IOException { FeatureModel featureModel = loadUVLFeatureModelFromFile("test.uvl"); + UVLModelFactory uvlModelFactory = new UVLModelFactory(); - //traverse all features depth first search - traverseAllFeatures(featureModel.getRootFeature()); - - //get constraints of feature model from constraints section (no constraints from submodels or attribtues) - List ownConstraint = featureModel.getOwnConstraints(); - - //traverse a constraint depth first search - if (ownConstraint.size() > 0) { - traverseConstraint(ownConstraint.get(0)); - } - - //get all constraints of feature model and submodels and attributes - List allConstraint = featureModel.getConstraints(); - - //get attribute from feature - String featureName = "featureName"; - String attributeName = "attributeName"; - Feature feature = featureModel.getFeatureMap().get(featureName); - if (feature != null) { - Attribute attribute = feature.getAttributes().get(attributeName); - if (attribute != null) { - Object value = attribute.getValue(); - System.out.println("Attribute " + attributeName + " of feature " + featureName + " is: " + value.toString()); - } else { - System.err.println("Attribute " + attributeName + " in feature " + featureName + " not found!"); - } - } else { - System.err.println("Feature " + featureName + " not found!"); - } - - //make feature abstract - featureName = "featureName"; - feature = featureModel.getFeatureMap().get(featureName); - if (feature != null) { - feature.getAttributes().put("abstract", new Attribute<>("abstract", true, feature)); - } else { - System.err.println("Feature " + featureName + " not found!"); - } - - //change newline and tabulator symbol for printing - Configuration.setTabulatorSymbol(" "); - Configuration.setNewlineSymbol("\n"); - - //safe a single uvl model (this ignores any submodels) - String uvlModel = featureModel.toString(); - Path filePath = Paths.get("test_singleModel.uvl"); - Files.write(filePath, uvlModel.getBytes()); - - //safe a decomposed uvl model with all its submodels to individual files - Map modelList = featureModel.decomposedModelToString(); - for (Map.Entry uvlSubModel : modelList.entrySet()) { - //safe submodel in sub directory directory with namespace as name - Files.createDirectories(Paths.get("./subModels/")); - filePath = Paths.get("./subModels/" + uvlSubModel.getKey() + ".uvl"); - Files.write(filePath, uvlSubModel.getValue().getBytes()); - } - - //create a single uvl representation from a decomposed model and safe it to a single file - uvlModel = featureModel.composedModelToString(); - filePath = Paths.get("test_composedModel.uvl"); - Files.write(filePath, uvlModel.getBytes()); + //Set levels = new HashSet<>(); + //levels.add(LanguageLevel.BOOLEAN_LEVEL); + //uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); + //System.out.println(featureModel.composedModelToString()); + System.out.println(featureModel.toOPBString()); } /** diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index 2aa7666..d321e33 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -369,6 +369,71 @@ public String toString() { return toString(true, ""); } + public String toOPBString() { + String result = ""; + List childGroups = getChildren(); + for (Group group : childGroups){ + switch (group.GROUPTYPE) { + case OPTIONAL: + result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + for (Feature child : group.getFeatures()){ + result += " -1 * " + child.getFeatureName().replace(" ", "_"); + } + result += " >= 0;\n"; + break; + case MANDATORY: + result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + for (Feature child : group.getFeatures()){ + result += " -1 * " + child.getFeatureName().replace(" ", "_"); + } + result += " = 0;\n"; + break; + case OR: + result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + for (Feature child : group.getFeatures()){ + result += " -1 * " + child.getFeatureName().replace(" ", "_"); + } + result += " <= " + (group.getFeatures().size() - 1) + ";\n"; + result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + for (Feature child : group.getFeatures()){ + result += " -1 * " + child.getFeatureName().replace(" ", "_"); + } + result += " >= 0;\n"; + break; + case ALTERNATIVE: + result += getFeatureName(); + for (Feature child : group.getFeatures()){ + result += " -1 * " + child.getFeatureName().replace(" ", "_"); + } + result += " = 0;\n"; + break; + case GROUP_CARDINALITY: + //TODO: Lastminute, check tomorrow if correct + result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + for (Feature child : group.getFeatures()){ + result += " -1 * " + child.getFeatureName().replace(" ", "_"); + } + result += " >= 0;\n"; + result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + for (Feature child : group.getFeatures()){ + result += " -1 * " + child.getFeatureName().replace(" ", "_"); + } + result += " >= " + (group.getFeatures().size() - group.getCardinality().upper) + ";\n"; + result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + for (Feature child : group.getFeatures()){ + result += " -1 * " + child.getFeatureName().replace(" ", "_"); + } + result += " <= " + (group.getFeatures().size() - group.getCardinality().lower) + ";\n"; + } + for (Feature child : group.getFeatures()){ + if(child.getChildren().size() > 0) { + result += child.toOPBString(); + } + } + } + return result; + } + /** * This method is necessary because the uvl string representation differs * between the feature as imported feature another feature model or as the root diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 8965ed5..96c6c7c 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -254,6 +254,13 @@ public String toString() { return toString(false, ""); } + public String toOPBString(){ + String result = ""; + result += getRootFeature().getFeatureName().replace(" ", "_") + " >= 1;\n"; + result += getRootFeature().toOPBString(); + return result; + } + /** * Returns a single uvl feature model composed out of all submodels. To avoid * naming conflicts all feature names are changed and a unique id is added. If From 1a03d01c4926e31e7b0dd33b2bc120688ddb655d Mon Sep 17 00:00:00 2001 From: Stefan Date: Fri, 13 Sep 2024 15:42:06 +0200 Subject: [PATCH 02/60] feat: worked on pseudo boolean encoding --- src/main/java/de/vill/main/Example.java | 16 +++++-- src/main/java/de/vill/model/Feature.java | 2 +- .../vill/model/constraint/AndConstraint.java | 47 +++++++++++++++++-- .../de/vill/model/constraint/Constraint.java | 5 ++ .../constraint/EquivalenceConstraint.java | 41 ++++++++++++++-- .../constraint/ImplicationConstraint.java | 40 ++++++++++++++-- .../vill/model/constraint/NotConstraint.java | 5 ++ .../vill/model/constraint/OrConstraint.java | 47 +++++++++++++++++-- .../constraint/ParenthesisConstraint.java | 5 ++ src/main/java/de/vill/util/Util.java | 33 +++++++++++++ 10 files changed, 219 insertions(+), 22 deletions(-) diff --git a/src/main/java/de/vill/main/Example.java b/src/main/java/de/vill/main/Example.java index 7bc097b..704232e 100644 --- a/src/main/java/de/vill/main/Example.java +++ b/src/main/java/de/vill/main/Example.java @@ -8,13 +8,11 @@ import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; public class Example { public static void main(String[] args) throws IOException { + FeatureModel featureModel = loadUVLFeatureModelFromFile("test.uvl"); UVLModelFactory uvlModelFactory = new UVLModelFactory(); @@ -22,7 +20,15 @@ public static void main(String[] args) throws IOException { //levels.add(LanguageLevel.BOOLEAN_LEVEL); //uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); //System.out.println(featureModel.composedModelToString()); - System.out.println(featureModel.toOPBString()); + //System.out.println(featureModel.toOPBString()); + + var c = featureModel.getConstraints().get(0); + HashMap subMap = new HashMap<>(); + int n = 1; + c.extractTseitinSubConstraints(subMap, n); + System.out.println(subMap.toString()); + + } /** diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index d321e33..e729f2b 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -408,7 +408,6 @@ public String toOPBString() { result += " = 0;\n"; break; case GROUP_CARDINALITY: - //TODO: Lastminute, check tomorrow if correct result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); for (Feature child : group.getFeatures()){ result += " -1 * " + child.getFeatureName().replace(" ", "_"); @@ -431,6 +430,7 @@ public String toOPBString() { } } } + return result; } diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index 1eea5f4..7fb0b1b 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -2,10 +2,10 @@ import de.vill.model.building.VariableReference; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; +import java.util.*; + +import static de.vill.util.Util.isJustAnd; +import static de.vill.util.Util.isJustOr; public class AndConstraint extends Constraint { private Constraint left; @@ -77,4 +77,43 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } + + public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + int a1 = 0; + if(!isJustAnd(left) ){ + a1 = left.extractTseitinSubConstraints(substitutionMapping, n); + } + int a2 = 0; + if(!isJustAnd(right)){ + a2 = right.extractTseitinSubConstraints(substitutionMapping, n); + } + int finalA = a1; + Constraint l1 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA; + } + }); + int finalA1 = a2; + Constraint l2 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA1; + } + }); + if(a1 == 0) { + l1 = left; + }else{ + n++; + } + if(a2 == 0) { + l2 = right; + }else{ + n++; + } + + AndConstraint newConstraint = new AndConstraint(l1, l2); + substitutionMapping.put(n, newConstraint); + return n; + }; } diff --git a/src/main/java/de/vill/model/constraint/Constraint.java b/src/main/java/de/vill/model/constraint/Constraint.java index a10a567..bfdc1b1 100644 --- a/src/main/java/de/vill/model/constraint/Constraint.java +++ b/src/main/java/de/vill/model/constraint/Constraint.java @@ -3,6 +3,7 @@ import de.vill.model.building.VariableReference; import java.util.List; +import java.util.Map; public abstract class Constraint { public int getLineNumber() { @@ -40,4 +41,8 @@ public int hashCode() { public abstract boolean equals(Object obj); public abstract List getReferences(); + + public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + return 0; + }; } diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index 024a291..c9c59c8 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -2,10 +2,9 @@ import de.vill.model.building.VariableReference; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; +import java.util.*; + +import static de.vill.util.Util.isJustAnd; public class EquivalenceConstraint extends Constraint { private Constraint left; @@ -80,4 +79,38 @@ public List getReferences() { return references; } + public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + int a1 = left.extractTseitinSubConstraints(substitutionMapping, n); + int a2 = right.extractTseitinSubConstraints(substitutionMapping, a1+1); + + int finalA = a1; + Constraint l1 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA; + } + }); + int finalA1 = a2; + Constraint l2 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA1; + } + }); + if(a1 == 0) { + l1 = left; + }else{ + n++; + } + if(a2 == 0) { + l2 = right; + }else{ + n++; + } + + EquivalenceConstraint newConstraint = new EquivalenceConstraint(l1, l2); + substitutionMapping.put(n, newConstraint); + return n; + }; + } diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index d85bba0..cff3644 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -2,10 +2,9 @@ import de.vill.model.building.VariableReference; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; +import java.util.*; + +import static de.vill.util.Util.isJustAnd; public class ImplicationConstraint extends Constraint { private Constraint left; @@ -79,4 +78,37 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } + + public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + int a1 = left.extractTseitinSubConstraints(substitutionMapping, n); + int a2 = right.extractTseitinSubConstraints(substitutionMapping, a1+1); + int finalA = a1; + Constraint l1 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA; + } + }); + int finalA1 = a2; + Constraint l2 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA1; + } + }); + if(a1 == 0) { + l1 = left; + }else{ + n++; + } + if(a2 == 0) { + l2 = right; + }else{ + n++; + } + + ImplicationConstraint newConstraint = new ImplicationConstraint(l1, l2); + substitutionMapping.put(n, newConstraint); + return n; + }; } diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index aa2dbc7..99fae27 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -4,6 +4,7 @@ import java.util.Arrays; import java.util.List; +import java.util.Map; import java.util.Objects; public class NotConstraint extends Constraint { @@ -69,4 +70,8 @@ public boolean equals(Object obj) { public List getReferences() { return content.getReferences(); } + + public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + return content.extractTseitinSubConstraints(substitutionMapping, n); + }; } diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index f770df8..73fd459 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -2,10 +2,10 @@ import de.vill.model.building.VariableReference; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; +import java.util.*; + +import static de.vill.util.Util.isJustAnd; +import static de.vill.util.Util.isJustOr; public class OrConstraint extends Constraint { @@ -78,4 +78,43 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } + + public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + int a1 = 0; + if(!isJustOr(left)){ + a1 = left.extractTseitinSubConstraints(substitutionMapping, n); + } + int a2 = 0; + if(!isJustOr(right)){ + a2 = right.extractTseitinSubConstraints(substitutionMapping, n); + } + int finalA = a1; + Constraint l1 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA; + } + }); + int finalA1 = a2; + Constraint l2 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA1; + } + }); + if(a1 == 0) { + l1 = left; + }else{ + n = a1 + 1; + } + if(a2 == 0) { + l2 = right; + }else{ + n = a2 + 1; + } + + OrConstraint newConstraint = new OrConstraint(l1, l2); + substitutionMapping.put(n, newConstraint); + return n; + }; } diff --git a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java index 52b03fe..7824186 100644 --- a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java +++ b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java @@ -4,6 +4,7 @@ import java.util.Arrays; import java.util.List; +import java.util.Map; import java.util.Objects; public class ParenthesisConstraint extends Constraint { @@ -62,4 +63,8 @@ public boolean equals(Object obj) { public List getReferences() { return content.getReferences(); } + + public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + return content.extractTseitinSubConstraints(substitutionMapping, n); + }; } diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 1ae573c..2f387b9 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -1,6 +1,7 @@ package de.vill.util; import de.vill.config.Configuration; +import de.vill.model.constraint.*; import java.io.IOException; import java.nio.file.Files; @@ -44,4 +45,36 @@ public static String readFileContent(Path file) { throw new RuntimeException(e); } } + + public static boolean isJustAnd(Constraint constraint){ + if(constraint instanceof ParenthesisConstraint){ + return isJustAnd(((ParenthesisConstraint) constraint).getContent()); + } + if(constraint instanceof LiteralConstraint){ + return true; + } + if(constraint instanceof NotConstraint){ + return isJustAnd(((NotConstraint) constraint).getContent()); + } + if(constraint instanceof AndConstraint && isJustAnd(((AndConstraint) constraint).getLeft()) && isJustAnd(((AndConstraint) constraint).getRight())){ + return true; + } + return false; + } + + public static boolean isJustOr(Constraint constraint){ + if(constraint instanceof ParenthesisConstraint){ + return isJustOr(((ParenthesisConstraint) constraint).getContent()); + } + if(constraint instanceof LiteralConstraint){ + return true; + } + if(constraint instanceof NotConstraint){ + return isJustOr(((NotConstraint) constraint).getContent()); + } + if(constraint instanceof OrConstraint && isJustOr(((OrConstraint) constraint).getLeft()) && isJustOr(((OrConstraint) constraint).getRight())){ + return true; + } + return false; + } } From 3fdc06df623d5e634867b418f16783afef5ce17c Mon Sep 17 00:00:00 2001 From: Stefan Date: Fri, 13 Sep 2024 20:46:00 +0200 Subject: [PATCH 03/60] feat: added constraint to pbc translation --- src/main/java/de/vill/main/Example.java | 7 +- .../vill/model/constraint/AndConstraint.java | 6 +- .../constraint/EquivalenceConstraint.java | 6 +- .../constraint/ImplicationConstraint.java | 6 +- .../vill/model/constraint/NotConstraint.java | 21 +- .../vill/model/constraint/OrConstraint.java | 2 +- src/main/java/de/vill/util/Util.java | 292 +++++++++++++++++- 7 files changed, 326 insertions(+), 14 deletions(-) diff --git a/src/main/java/de/vill/main/Example.java b/src/main/java/de/vill/main/Example.java index 704232e..1c76b76 100644 --- a/src/main/java/de/vill/main/Example.java +++ b/src/main/java/de/vill/main/Example.java @@ -3,6 +3,7 @@ import de.vill.config.Configuration; import de.vill.model.*; import de.vill.model.constraint.Constraint; +import de.vill.model.pbc.PBCConstraint; import java.io.IOException; import java.nio.file.Files; @@ -10,6 +11,8 @@ import java.nio.file.Paths; import java.util.*; +import static de.vill.util.Util.*; + public class Example { public static void main(String[] args) throws IOException { @@ -26,7 +29,9 @@ public static void main(String[] args) throws IOException { HashMap subMap = new HashMap<>(); int n = 1; c.extractTseitinSubConstraints(subMap, n); - System.out.println(subMap.toString()); + var map = transformSubFormulas(subMap); + List pbcList = transformImplicationMap(map); + System.out.println(pbcList.toString()); } diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index 7fb0b1b..09c667c 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -104,15 +104,15 @@ public String getIdentifier() { if(a1 == 0) { l1 = left; }else{ - n++; + n = a1 + 1; } if(a2 == 0) { l2 = right; }else{ - n++; + n = a2 + 1; } - AndConstraint newConstraint = new AndConstraint(l1, l2); + Constraint newConstraint = new AndConstraint(l1, l2); substitutionMapping.put(n, newConstraint); return n; }; diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index c9c59c8..7a62436 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -100,15 +100,15 @@ public String getIdentifier() { if(a1 == 0) { l1 = left; }else{ - n++; + n = a1 + 1; } if(a2 == 0) { l2 = right; }else{ - n++; + n = a2 + 1; } - EquivalenceConstraint newConstraint = new EquivalenceConstraint(l1, l2); + Constraint newConstraint = new EquivalenceConstraint(l1, l2); substitutionMapping.put(n, newConstraint); return n; }; diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index cff3644..e939d3d 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -99,15 +99,15 @@ public String getIdentifier() { if(a1 == 0) { l1 = left; }else{ - n++; + n = a1 + 1; } if(a2 == 0) { l2 = right; }else{ - n++; + n = a2 + 1; } - ImplicationConstraint newConstraint = new ImplicationConstraint(l1, l2); + Constraint newConstraint = new ImplicationConstraint(l1, l2); substitutionMapping.put(n, newConstraint); return n; }; diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index 99fae27..9dca4bd 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -72,6 +72,25 @@ public List getReferences() { } public int extractTseitinSubConstraints(Map substitutionMapping, int n) { - return content.extractTseitinSubConstraints(substitutionMapping, n); + if (content instanceof LiteralConstraint){ + return 0; + } + int a1 = content.extractTseitinSubConstraints(substitutionMapping, n); + int finalA = a1; + Constraint l1 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + finalA; + } + }); + if(a1 == 0) { + l1 = content; + }else{ + n = a1 + 1; + } + + Constraint newConstraint = new NotConstraint(l1); + substitutionMapping.put(n, newConstraint); + return n; }; } diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index 73fd459..eb39310 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -113,7 +113,7 @@ public String getIdentifier() { n = a2 + 1; } - OrConstraint newConstraint = new OrConstraint(l1, l2); + Constraint newConstraint = new OrConstraint(l1, l2); substitutionMapping.put(n, newConstraint); return n; }; diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 2f387b9..753a0a2 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -2,10 +2,16 @@ import de.vill.config.Configuration; import de.vill.model.constraint.*; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; public class Util { public static String indentEachLine(String text) { @@ -54,7 +60,7 @@ public static boolean isJustAnd(Constraint constraint){ return true; } if(constraint instanceof NotConstraint){ - return isJustAnd(((NotConstraint) constraint).getContent()); + return ((NotConstraint) constraint).getContent() instanceof LiteralConstraint; } if(constraint instanceof AndConstraint && isJustAnd(((AndConstraint) constraint).getLeft()) && isJustAnd(((AndConstraint) constraint).getRight())){ return true; @@ -70,11 +76,293 @@ public static boolean isJustOr(Constraint constraint){ return true; } if(constraint instanceof NotConstraint){ - return isJustOr(((NotConstraint) constraint).getContent()); + return ((NotConstraint) constraint).getContent() instanceof LiteralConstraint; } if(constraint instanceof OrConstraint && isJustOr(((OrConstraint) constraint).getLeft()) && isJustOr(((OrConstraint) constraint).getRight())){ return true; } return false; } + + public static List transformImplicationMap (HashMap> implicationMap){ + List resultList = new LinkedList<>(); + int max = 0; + for (Map.Entry> entry : implicationMap.entrySet()) { + int x = entry.getKey(); + if(x > max) { + max = x; + } + for(PBCConstraint constraint : entry.getValue()){ + //x <=> constraint + PBCConstraint c2 = new PBCConstraint(); + c2.literalList = new LinkedList<>(); + c2.k = constraint.k; + for(Literal lit : constraint.literalList){ + Literal l2 = new Literal(); + l2.factor = lit.factor; + l2.name = lit.name; + c2.literalList.add(l2); + } + + //-x v constraint + int f = constraint.k; + for(Literal lit : constraint.literalList){ + f += Math.abs(lit.factor); + } + Literal l1 = new Literal(); + l1.name = "x_" + x; + l1.factor = -f; + constraint.k = constraint.k - f; + constraint.literalList.add(l1); + resultList.add(constraint); + + //x v -constraint + for(Literal lit : c2.literalList){ + lit.factor = -1 * lit.factor; + } + c2.k = -1 * c2.k + 1; + f = c2.k; + for(Literal lit : c2.literalList){ + f += Math.abs(lit.factor); + } + Literal l2 = new Literal(); + l2.name = "x_" + x; + l2.factor = f; + c2.literalList.add(l2); + resultList.add(c2); + } + + } + PBCConstraint finalPBCConstraint = new PBCConstraint(); + finalPBCConstraint.literalList = new LinkedList<>(); + Literal l = new Literal(); + l.factor = 1; + l.name = "x_" + max; + finalPBCConstraint.literalList.add(l); + finalPBCConstraint.k = 1; + resultList.add(finalPBCConstraint); + return resultList; + } + + public static HashMap> transformSubFormulas(HashMap subformulas){ + HashMap> resultMap = new HashMap<>(); + for (Map.Entry entry : subformulas.entrySet()) { + resultMap.put(entry.getKey(), transformSubFormula(entry.getValue())); + } + return resultMap; + } + + public static List transformSubFormula(Constraint constraint){ + List resultList = new LinkedList<>(); + if(constraint instanceof NotConstraint){ + resultList.add(transformNegLiteral((NotConstraint) constraint)); + } else if (constraint instanceof ImplicationConstraint) { + resultList.add(transformImplication((ImplicationConstraint) constraint)); + } else if (constraint instanceof EquivalenceConstraint) { + resultList.addAll(transformBiImplication((EquivalenceConstraint) constraint)); + } + else if (constraint instanceof AndConstraint) { + resultList.add(transformAnd((AndConstraint) constraint)); + } + else if (constraint instanceof OrConstraint) { + var orConstraint = transformOr((OrConstraint) constraint); + orConstraint.k = orConstraint.k + 1; + resultList.add(orConstraint); + } + return resultList; + } + + public static PBCConstraint transformNegLiteral(NotConstraint constraint){ + Literal literal = new Literal(); + literal.name = ((LiteralConstraint)constraint.getContent()).getReference().getIdentifier(); + literal.factor = -1; + PBCConstraint pbcConstraint = new PBCConstraint(); + pbcConstraint.k = 0; + pbcConstraint.literalList = new LinkedList<>(); + pbcConstraint.literalList.add(literal); + return pbcConstraint; + } + + public static PBCConstraint transformImplication(ImplicationConstraint constraint){ + Literal l1 = new Literal(); + l1.name = ((LiteralConstraint)((ImplicationConstraint)constraint).getLeft()).getReference().getIdentifier(); + l1.factor = -1; + Literal l2 = new Literal(); + l2.name = ((LiteralConstraint)((ImplicationConstraint)constraint).getRight()).getReference().getIdentifier(); + l2.factor = 1; + PBCConstraint pbcConstraint = new PBCConstraint(); + pbcConstraint.k = 0; + pbcConstraint.literalList = new LinkedList<>(); + pbcConstraint.literalList.add(l1); + pbcConstraint.literalList.add(l2); + return pbcConstraint; + } + + public static List transformBiImplication(EquivalenceConstraint constraint){ + Constraint c1 = constraint.getLeft(); + Constraint c2 = constraint.getRight(); + Literal l1 = new Literal(); + Literal l2 = new Literal(); + if(c1 instanceof NotConstraint && c2 instanceof NotConstraint){ + l1.name = ((LiteralConstraint)(((NotConstraint) c1).getContent())).getReference().getIdentifier(); + l2.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); + l1.factor = 1; + l2.factor = -1; + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.k = 0; + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.literalList.add(l1); + pbcConstraint1.literalList.add(l2); + + Literal l1_1 = new Literal(); + Literal l2_1 = new Literal(); + l1_1.name = ((LiteralConstraint)(((NotConstraint) c1).getContent())).getReference().getIdentifier(); + l2_1.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); + l1_1.factor = -1; + l2_1.factor = 1; + PBCConstraint pbcConstraint2 = new PBCConstraint(); + pbcConstraint2.k = 0; + pbcConstraint2.literalList = new LinkedList<>(); + pbcConstraint2.literalList.add(l1_1); + pbcConstraint2.literalList.add(l2_1); + + List constraintList = new LinkedList<>(); + constraintList.add(pbcConstraint1); + constraintList.add(pbcConstraint2); + return constraintList; + }else if(c1 instanceof LiteralConstraint && c2 instanceof LiteralConstraint){ + l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l2.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l1.factor = 1; + l2.factor = -1; + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.k = 0; + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.literalList.add(l1); + pbcConstraint1.literalList.add(l2); + + Literal l1_1 = new Literal(); + Literal l2_1 = new Literal(); + l1_1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l2_1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l1_1.factor = -1; + l2_1.factor = 1; + PBCConstraint pbcConstraint2 = new PBCConstraint(); + pbcConstraint2.k = 0; + pbcConstraint2.literalList = new LinkedList<>(); + pbcConstraint2.literalList.add(l1_1); + pbcConstraint2.literalList.add(l2_1); + + List constraintList = new LinkedList<>(); + constraintList.add(pbcConstraint1); + constraintList.add(pbcConstraint2); + return constraintList; + }else if (c1 instanceof NotConstraint) { + l1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); + l1.factor = -1; + l2.name = ((LiteralConstraint) (c2)).getReference().getIdentifier(); + l2.factor = -1; + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.k = -1; + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.literalList.add(l1); + pbcConstraint1.literalList.add(l2); + + Literal l1_1 = new Literal(); + l1_1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); + l1_1.factor = 1; + Literal l2_1 = new Literal(); + l2_1.name = ((LiteralConstraint) c2).getReference().getIdentifier(); + l2_1.factor = 1; + PBCConstraint pbcConstraint2 = new PBCConstraint(); + pbcConstraint2.k = 1; + pbcConstraint2.literalList = new LinkedList<>(); + pbcConstraint2.literalList.add(l1); + pbcConstraint2.literalList.add(l2); + List constraintList = new LinkedList<>(); + constraintList.add(pbcConstraint1); + constraintList.add(pbcConstraint2); + return constraintList; + }else{ + l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l2.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); + l1.factor = 1; + l2.factor = 1; + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.k = 1; + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.literalList.add(l1); + pbcConstraint1.literalList.add(l2); + + Literal l1_1 = new Literal(); + Literal l2_1 = new Literal(); + l1_1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l2_1.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); + l1_1.factor = -1; + l2_1.factor = -1; + PBCConstraint pbcConstraint2 = new PBCConstraint(); + pbcConstraint2.k = -1; + pbcConstraint2.literalList = new LinkedList<>(); + pbcConstraint2.literalList.add(l1_1); + pbcConstraint2.literalList.add(l2_1); + + List constraintList = new LinkedList<>(); + constraintList.add(pbcConstraint1); + constraintList.add(pbcConstraint2); + return constraintList; + } + } + + public static PBCConstraint transformAnd(Constraint constraint){ + if(constraint instanceof AndConstraint){ + PBCConstraint pbcConstraint1 = transformAnd(((AndConstraint) constraint).getLeft()); + PBCConstraint pbcConstraint2 = transformAnd(((AndConstraint) constraint).getRight()); + pbcConstraint1.k = pbcConstraint1.k + pbcConstraint2.k; + pbcConstraint1.literalList.addAll(pbcConstraint2.literalList); + return pbcConstraint1; + }else{ + Literal l1 = new Literal(); + PBCConstraint pbcConstraint = new PBCConstraint(); + if(constraint instanceof NotConstraint){ + l1.name = ((LiteralConstraint)((NotConstraint) constraint).getContent()).getReference().getIdentifier(); + l1.factor = -1; + pbcConstraint.k = 0; + }else{ + l1.name = ((LiteralConstraint)constraint).getReference().getIdentifier(); + l1.factor = 1; + pbcConstraint.k = 1; + } + + pbcConstraint.literalList = new LinkedList<>(); + pbcConstraint.literalList.add(l1); + return pbcConstraint; + } + } + + public static PBCConstraint transformOr(Constraint constraint){ + if(constraint instanceof OrConstraint){ + PBCConstraint pbcConstraint1 = transformAnd(((OrConstraint) constraint).getLeft()); + PBCConstraint pbcConstraint2 = transformAnd(((OrConstraint) constraint).getRight()); + pbcConstraint1.k = pbcConstraint1.literalList.size() + pbcConstraint2.literalList.size(); + pbcConstraint1.literalList.addAll(pbcConstraint2.literalList); + return pbcConstraint1; + }else{ + Literal l1 = new Literal(); + PBCConstraint pbcConstraint = new PBCConstraint(); + if(constraint instanceof NotConstraint){ + l1.name = ((LiteralConstraint)((NotConstraint) constraint).getContent()).getReference().getIdentifier(); + l1.factor = -1; + pbcConstraint.k = -1; + }else{ + l1.name = ((LiteralConstraint)constraint).getReference().getIdentifier(); + l1.factor = 1; + pbcConstraint.k = 0; + } + + pbcConstraint.literalList = new LinkedList<>(); + pbcConstraint.literalList.add(l1); + return pbcConstraint; + } + } + } From 027596b1072fc7c8cc4d280082eef4bd19f7fac2 Mon Sep 17 00:00:00 2001 From: Stefan Date: Sat, 14 Sep 2024 12:07:03 +0200 Subject: [PATCH 04/60] fix: constraint pbc encoding --- .idea/.gitignore | 3 + .idea/compiler.xml | 13 + .idea/encodings.xml | 7 + .idea/jarRepositories.xml | 20 + .idea/misc.xml | 12 + .idea/vcs.xml | 6 + model.uvl | 45 + src/main/java/de/vill/main/Example.java | 44 +- src/main/java/de/vill/model/FeatureModel.java | 17 +- .../vill/model/constraint/AndConstraint.java | 10 +- .../de/vill/model/constraint/Constraint.java | 2 +- .../constraint/EquivalenceConstraint.java | 10 +- .../constraint/ImplicationConstraint.java | 10 +- .../vill/model/constraint/NotConstraint.java | 6 +- .../vill/model/constraint/OrConstraint.java | 10 +- .../constraint/ParenthesisConstraint.java | 4 +- src/main/java/de/vill/model/pbc/Literal.java | 6 + .../java/de/vill/model/pbc/PBCConstraint.java | 23 + src/main/java/de/vill/util/Util.java | 75 +- subModels/Server.uvl | 21 + submodels/FBTree.uvl | 19 + submodels/FConcurrency.uvl | 11 + submodels/FLogging.uvl | 19 + submodels/FPersistency.uvl | 39 + submodels/FStatistics.uvl | 27 + test.uvl | 6241 +++++++++++++++++ test2.uvl | 10 + test_composedModel.uvl | 21 + test_singleModel.uvl | 21 + 29 files changed, 6704 insertions(+), 48 deletions(-) create mode 100644 .idea/.gitignore create mode 100644 .idea/compiler.xml create mode 100644 .idea/encodings.xml create mode 100644 .idea/jarRepositories.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/vcs.xml create mode 100644 model.uvl create mode 100644 src/main/java/de/vill/model/pbc/Literal.java create mode 100644 src/main/java/de/vill/model/pbc/PBCConstraint.java create mode 100644 subModels/Server.uvl create mode 100644 submodels/FBTree.uvl create mode 100644 submodels/FConcurrency.uvl create mode 100644 submodels/FLogging.uvl create mode 100644 submodels/FPersistency.uvl create mode 100644 submodels/FStatistics.uvl create mode 100644 test.uvl create mode 100644 test2.uvl create mode 100644 test_composedModel.uvl create mode 100644 test_singleModel.uvl diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/compiler.xml b/.idea/compiler.xml new file mode 100644 index 0000000..59b2d44 --- /dev/null +++ b/.idea/compiler.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/encodings.xml b/.idea/encodings.xml new file mode 100644 index 0000000..aa00ffa --- /dev/null +++ b/.idea/encodings.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml new file mode 100644 index 0000000..712ab9d --- /dev/null +++ b/.idea/jarRepositories.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..f0f8287 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,12 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/model.uvl b/model.uvl new file mode 100644 index 0000000..602e9f4 --- /dev/null +++ b/model.uvl @@ -0,0 +1,45 @@ +namespace BerkeleyDb + +imports + submodels.FLogging as fl + submodels.FBTree as fbt + submodels.FPersistency as fp + submodels.FConcurrency as fc + submodels.FStatistics as fs + +features + BerkeleyDb {abstract true} + optional + BerkeleyDB {abstract true} + mandatory + BASE + fp.FPersistency + fbt.FBtree + optional + fl.FLogging + fs.FStatistics + fc.FConcurrency + featureMemoryBudget + FDbOperation {abstract true} + or + featureDeleteDb + featureTruncateDb + +constraints + fbt.featureEvictor | fbt.featureEvictorDaemon | fp.featureLookAheadCache | fs.featureStatisticsEnvCaching => featureMemoryBudget + fc.featureCheckLeaks => fs.featureStatisticsLock + fbt.featureCriticalEviction => fbt.featureINCompressor + fp.featureCustomizableCheckpointerBytes => fp.featureCustomizableCheckpointerTime + featureDeleteDb => fc.dummyFeatureLocking & fbt.featureEvictor & fbt.featureINCompressor & featureMemoryBudget + fc.featureLatch => fc.dummyFeatureLocking & fc.featureCheckLeaks & featureDeleteDb & fbt.featureEvictor & fp.featureFileHandleCache & fc.featureFSync & fbt.featureINCompressor & featureMemoryBudget & fs.featureStatisticsLock & fbt.featureTreeVisitor & featureTruncateDb & fbt.featureVerifier + fl.featureLoggingFine => fc.dummyFeatureLocking & fbt.featureEvictor & fbt.featureINCompressor + fl.featureLoggingBase | fl.featureLoggingFinest => fc.featureTransaction + featureMemoryBudget => fbt.featureEvictor & fc.featureLatch + fs.featureStatisticsLock | fs.featureStatisticsTransaction => fc.dummyFeatureLocking + fs.featureStatisticsEnvEvictor => fbt.featureEvictor + fs.featureStatisticsEnvFSync => fc.featureFSync + fs.featureStatisticsTransaction => fc.featureTransaction + fs.featureStatisticsDatabase => fbt.featureTreeVisitor + fc.featureTransaction => fc.dummyFeatureLocking & featureDeleteDb & featureTruncateDb + featureTruncateDb => featureDeleteDb + fbt.featureVerifier => fbt.featureINCompressor & fbt.featureTreeVisitor diff --git a/src/main/java/de/vill/main/Example.java b/src/main/java/de/vill/main/Example.java index 1c76b76..66089c3 100644 --- a/src/main/java/de/vill/main/Example.java +++ b/src/main/java/de/vill/main/Example.java @@ -3,8 +3,10 @@ import de.vill.config.Configuration; import de.vill.model.*; import de.vill.model.constraint.Constraint; +import de.vill.model.pbc.Literal; import de.vill.model.pbc.PBCConstraint; +import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; @@ -18,13 +20,17 @@ public static void main(String[] args) throws IOException { FeatureModel featureModel = loadUVLFeatureModelFromFile("test.uvl"); UVLModelFactory uvlModelFactory = new UVLModelFactory(); + System.out.println(featureModel.toOPBString()); + + //Set levels = new HashSet<>(); //levels.add(LanguageLevel.BOOLEAN_LEVEL); //uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); //System.out.println(featureModel.composedModelToString()); - //System.out.println(featureModel.toOPBString()); + + /* var c = featureModel.getConstraints().get(0); HashMap subMap = new HashMap<>(); int n = 1; @@ -33,6 +39,42 @@ public static void main(String[] args) throws IOException { List pbcList = transformImplicationMap(map); System.out.println(pbcList.toString()); + */ +//dimacsToOPB("/home/stefan/stefan-vill-master/tmp_eval/tmp5.dimacs"); + + } + + private static void dimacsToOPB(String path) throws IOException { + String[] lines = new String(Files.readAllBytes(Paths.get(path))).split("\n"); + List constraintList = new LinkedList<>(); + + for(String line : lines){ + if(!line.startsWith("c") && !line.startsWith("p")){ + PBCConstraint pbcConstraint = new PBCConstraint(); + pbcConstraint.literalList = new LinkedList<>(); + pbcConstraint.k = 1; + for(String l : line.split(" ")){ + int v = Integer.parseInt(l); + if(v > 0){ + Literal literal = new Literal(); + literal.name = "x_" + v; + literal.factor = 1; + pbcConstraint.literalList.add(literal); + }else if(v < 0){ + Literal literal = new Literal(); + literal.name = "x_" + (-1 * v); + literal.factor = -1; + pbcConstraint.literalList.add(literal); + pbcConstraint.k = pbcConstraint.k -1; + } + } + constraintList.add(pbcConstraint); + } + } + + for(PBCConstraint pbcConstraint : constraintList){ + System.out.println(pbcConstraint.toString() + ";"); + } } diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 96c6c7c..8eb9cfa 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -1,7 +1,5 @@ package de.vill.model; -import static de.vill.util.Util.addNecessaryQuotes; - import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; @@ -17,8 +15,11 @@ import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; import de.vill.model.expression.LiteralExpression; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Util; +import static de.vill.util.Util.*; + /** * This class represents a feature model and all its sub feature models if the * model is composed. @@ -258,6 +259,18 @@ public String toOPBString(){ String result = ""; result += getRootFeature().getFeatureName().replace(" ", "_") + " >= 1;\n"; result += getRootFeature().toOPBString(); + int counter = 0; + for(Constraint constraint : getConstraints()){ + HashMap subMap = new HashMap<>(); + int n = 1; + constraint.extractTseitinSubConstraints(subMap, n, counter); + var map = transformSubFormulas(subMap); + List pbcList = transformImplicationMap(map, counter); + for(PBCConstraint pbcConstraint : pbcList){ + result += pbcConstraint.toString() + ";\n"; + } + counter++; + } return result; } diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index 09c667c..ccdb57e 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -78,27 +78,27 @@ public List getReferences() { return references; } - public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { int a1 = 0; if(!isJustAnd(left) ){ - a1 = left.extractTseitinSubConstraints(substitutionMapping, n); + a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); } int a2 = 0; if(!isJustAnd(right)){ - a2 = right.extractTseitinSubConstraints(substitutionMapping, n); + a2 = right.extractTseitinSubConstraints(substitutionMapping, n, counter); } int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA; + return "x_" + counter + "_" + finalA; } }); int finalA1 = a2; Constraint l2 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA1; + return "x_" + counter + "_" + finalA1; } }); if(a1 == 0) { diff --git a/src/main/java/de/vill/model/constraint/Constraint.java b/src/main/java/de/vill/model/constraint/Constraint.java index bfdc1b1..366c7c8 100644 --- a/src/main/java/de/vill/model/constraint/Constraint.java +++ b/src/main/java/de/vill/model/constraint/Constraint.java @@ -42,7 +42,7 @@ public int hashCode() { public abstract List getReferences(); - public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { return 0; }; } diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index 7a62436..eca7899 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -79,22 +79,22 @@ public List getReferences() { return references; } - public int extractTseitinSubConstraints(Map substitutionMapping, int n) { - int a1 = left.extractTseitinSubConstraints(substitutionMapping, n); - int a2 = right.extractTseitinSubConstraints(substitutionMapping, a1+1); + public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { + int a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); + int a2 = right.extractTseitinSubConstraints(substitutionMapping, a1+1, counter); int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA; + return "x_" + counter + "_" + finalA; } }); int finalA1 = a2; Constraint l2 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA1; + return "x_" + counter + "_" + finalA1; } }); if(a1 == 0) { diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index e939d3d..aa104bc 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -79,21 +79,21 @@ public List getReferences() { return references; } - public int extractTseitinSubConstraints(Map substitutionMapping, int n) { - int a1 = left.extractTseitinSubConstraints(substitutionMapping, n); - int a2 = right.extractTseitinSubConstraints(substitutionMapping, a1+1); + public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { + int a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); + int a2 = right.extractTseitinSubConstraints(substitutionMapping, a1+1, counter); int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA; + return "x_" + counter + "_" + finalA; } }); int finalA1 = a2; Constraint l2 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA1; + return "x_" + counter + "_" + finalA1; } }); if(a1 == 0) { diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index 9dca4bd..e7439e3 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -71,16 +71,16 @@ public List getReferences() { return content.getReferences(); } - public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { if (content instanceof LiteralConstraint){ return 0; } - int a1 = content.extractTseitinSubConstraints(substitutionMapping, n); + int a1 = content.extractTseitinSubConstraints(substitutionMapping, n, counter); int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA; + return "x_" + counter + "_" + finalA; } }); if(a1 == 0) { diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index eb39310..b623d96 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -79,27 +79,27 @@ public List getReferences() { return references; } - public int extractTseitinSubConstraints(Map substitutionMapping, int n) { + public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { int a1 = 0; if(!isJustOr(left)){ - a1 = left.extractTseitinSubConstraints(substitutionMapping, n); + a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); } int a2 = 0; if(!isJustOr(right)){ - a2 = right.extractTseitinSubConstraints(substitutionMapping, n); + a2 = right.extractTseitinSubConstraints(substitutionMapping, n, counter); } int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA; + return "x_" + counter + "_" + finalA; } }); int finalA1 = a2; Constraint l2 = new LiteralConstraint(new VariableReference() { @Override public String getIdentifier() { - return "x_" + finalA1; + return "x_" + counter + "_" + finalA1; } }); if(a1 == 0) { diff --git a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java index 7824186..27b72fa 100644 --- a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java +++ b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java @@ -64,7 +64,7 @@ public List getReferences() { return content.getReferences(); } - public int extractTseitinSubConstraints(Map substitutionMapping, int n) { - return content.extractTseitinSubConstraints(substitutionMapping, n); + public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { + return content.extractTseitinSubConstraints(substitutionMapping, n, counter); }; } diff --git a/src/main/java/de/vill/model/pbc/Literal.java b/src/main/java/de/vill/model/pbc/Literal.java new file mode 100644 index 0000000..442f141 --- /dev/null +++ b/src/main/java/de/vill/model/pbc/Literal.java @@ -0,0 +1,6 @@ +package de.vill.model.pbc; + +public class Literal { + public String name; + public int factor; +} diff --git a/src/main/java/de/vill/model/pbc/PBCConstraint.java b/src/main/java/de/vill/model/pbc/PBCConstraint.java new file mode 100644 index 0000000..24306c2 --- /dev/null +++ b/src/main/java/de/vill/model/pbc/PBCConstraint.java @@ -0,0 +1,23 @@ +package de.vill.model.pbc; + +import java.util.List; + +public class PBCConstraint { + public List literalList; + public int k; + + @Override + public String toString() { + String res = ""; + for(Literal l : literalList){ + if(l.factor < 0){ + res += " " + l.factor; + }else{ + res += " +" + l.factor; + } + res += " " + l.name; + } + res += " >= " + k; + return res; + } +} diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 753a0a2..5052b1f 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -84,7 +84,7 @@ public static boolean isJustOr(Constraint constraint){ return false; } - public static List transformImplicationMap (HashMap> implicationMap){ + public static List transformImplicationMap (HashMap> implicationMap, int counter){ List resultList = new LinkedList<>(); int max = 0; for (Map.Entry> entry : implicationMap.entrySet()) { @@ -110,7 +110,7 @@ public static List transformImplicationMap (HashMap transformImplicationMap (HashMap transformImplicationMap (HashMap(); Literal l = new Literal(); l.factor = 1; - l.name = "x_" + max; + l.name = "x_" + counter + "_" + max; finalPBCConstraint.literalList.add(l); finalPBCConstraint.k = 1; resultList.add(finalPBCConstraint); @@ -184,18 +184,55 @@ public static PBCConstraint transformNegLiteral(NotConstraint constraint){ } public static PBCConstraint transformImplication(ImplicationConstraint constraint){ + Constraint c1 = constraint.getLeft(); + Constraint c2 = constraint.getRight(); Literal l1 = new Literal(); - l1.name = ((LiteralConstraint)((ImplicationConstraint)constraint).getLeft()).getReference().getIdentifier(); - l1.factor = -1; Literal l2 = new Literal(); - l2.name = ((LiteralConstraint)((ImplicationConstraint)constraint).getRight()).getReference().getIdentifier(); - l2.factor = 1; - PBCConstraint pbcConstraint = new PBCConstraint(); - pbcConstraint.k = 0; - pbcConstraint.literalList = new LinkedList<>(); - pbcConstraint.literalList.add(l1); - pbcConstraint.literalList.add(l2); - return pbcConstraint; + if(c1 instanceof NotConstraint && c2 instanceof NotConstraint){ + l1.name = ((LiteralConstraint)(((NotConstraint) c1).getContent())).getReference().getIdentifier(); + l2.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); + l1.factor = 1; + l2.factor = -1; + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.k = 0; + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.literalList.add(l1); + pbcConstraint1.literalList.add(l2); + return pbcConstraint1; + }else if(c1 instanceof LiteralConstraint && c2 instanceof LiteralConstraint){ + l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l2.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); + l1.factor = -1; + l2.factor = 1; + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.k = 0; + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.literalList.add(l1); + pbcConstraint1.literalList.add(l2); + return pbcConstraint1; + }else if (c1 instanceof NotConstraint) { + l1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); + l1.factor = 1; + l2.name = ((LiteralConstraint) (c2)).getReference().getIdentifier(); + l2.factor = 1; + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.k = 1; + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.literalList.add(l1); + pbcConstraint1.literalList.add(l2); + return pbcConstraint1; + }else{ + l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l2.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); + l1.factor = -1; + l2.factor = -1; + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.k = -1; + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.literalList.add(l1); + pbcConstraint1.literalList.add(l2); + return pbcConstraint1; + } } public static List transformBiImplication(EquivalenceConstraint constraint){ @@ -232,7 +269,7 @@ public static List transformBiImplication(EquivalenceConstraint c return constraintList; }else if(c1 instanceof LiteralConstraint && c2 instanceof LiteralConstraint){ l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); - l2.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l2.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); l1.factor = 1; l2.factor = -1; PBCConstraint pbcConstraint1 = new PBCConstraint(); @@ -244,7 +281,7 @@ public static List transformBiImplication(EquivalenceConstraint c Literal l1_1 = new Literal(); Literal l2_1 = new Literal(); l1_1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); - l2_1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); + l2_1.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); l1_1.factor = -1; l2_1.factor = 1; PBCConstraint pbcConstraint2 = new PBCConstraint(); @@ -341,9 +378,9 @@ public static PBCConstraint transformAnd(Constraint constraint){ public static PBCConstraint transformOr(Constraint constraint){ if(constraint instanceof OrConstraint){ - PBCConstraint pbcConstraint1 = transformAnd(((OrConstraint) constraint).getLeft()); - PBCConstraint pbcConstraint2 = transformAnd(((OrConstraint) constraint).getRight()); - pbcConstraint1.k = pbcConstraint1.literalList.size() + pbcConstraint2.literalList.size(); + PBCConstraint pbcConstraint1 = transformOr(((OrConstraint) constraint).getLeft()); + PBCConstraint pbcConstraint2 = transformOr(((OrConstraint) constraint).getRight()); + pbcConstraint1.k = pbcConstraint1.k + pbcConstraint2.k; pbcConstraint1.literalList.addAll(pbcConstraint2.literalList); return pbcConstraint1; }else{ diff --git a/subModels/Server.uvl b/subModels/Server.uvl new file mode 100644 index 0000000..7ce77e9 --- /dev/null +++ b/subModels/Server.uvl @@ -0,0 +1,21 @@ +namespace Server + +features + Server {abstract true} + mandatory + FileSystem + or + NTFS + APFS + EXT4 + OperatingSystem {abstract true} + alternative + Windows + macOS + Debian + optional + Logging {log_level 2, default true} + +constraints + Windows => NTFS + macOS => APFS diff --git a/submodels/FBTree.uvl b/submodels/FBTree.uvl new file mode 100644 index 0000000..70fd097 --- /dev/null +++ b/submodels/FBTree.uvl @@ -0,0 +1,19 @@ +namespace FBTree + +features + FBtree {abstract true} + optional + BTree {abstract true} + optional + featureVerifier + featureTreeVisitor + featureINCompressor + FEvictor {abstract true} + optional + Evictor {abstract true} + mandatory + featureEvictor + optional + featureCriticalEviction + featureEvictorDaemon + diff --git a/submodels/FConcurrency.uvl b/submodels/FConcurrency.uvl new file mode 100644 index 0000000..88a6efc --- /dev/null +++ b/submodels/FConcurrency.uvl @@ -0,0 +1,11 @@ +namespace FConcurrency + +features + FConcurrency {abstract true} + or + featureLatch + featureFSync + featureTransaction + dummyFeatureLocking + featureCheckLeaks + diff --git a/submodels/FLogging.uvl b/submodels/FLogging.uvl new file mode 100644 index 0000000..5f0f419 --- /dev/null +++ b/submodels/FLogging.uvl @@ -0,0 +1,19 @@ +namespace FLogging + +features + FLogging {abstract true} + optional + Logging {abstract true} + mandatory + featureLoggingBase + optional + featureLoggingFile + featureLoggingConsole + featureLoggingDbLog + featureLoggingFinest + featureLoggingFiner + featureLoggingFine + featureLoggingInfo + featureLoggingConfig + featureLoggingSevere + diff --git a/submodels/FPersistency.uvl b/submodels/FPersistency.uvl new file mode 100644 index 0000000..e89ae5b --- /dev/null +++ b/submodels/FPersistency.uvl @@ -0,0 +1,39 @@ +namespace FPersistency + +features + FPersistency {abstract true} + optional + Persistency {abstract true} + mandatory + FIOFeature {abstract true} + alternative + NIO {abstract true} + mandatory + FNIOType {abstract true} + alternative + featureNIO + featureChunkedNIO + optional + featureDirectNIO + IO {abstract true} + mandatory + featureIO + optional + featureSynchronizedIO + optional + FPersistencyFeatures {abstract true} + or + featureChecksum + featureFileHandleCache + featureHandleFullDiscError + featureEnvironmentLock + Checkpointer {abstract true} + optional + featureCustomizableCheckpointerTime + featureCustomizableCheckpointerBytes + featureCheckpointerDaemon + Cleaner {abstract true} + optional + featureLookAheadCache + featureCleanerDaemon + diff --git a/submodels/FStatistics.uvl b/submodels/FStatistics.uvl new file mode 100644 index 0000000..a29f4c4 --- /dev/null +++ b/submodels/FStatistics.uvl @@ -0,0 +1,27 @@ +namespace FStatistics + +features + FStatistics {abstract true} + optional + Statistics {abstract true} + mandatory + FStatisticsFeatures {abstract true} + or + EnvStats {abstract true} + mandatory + featureStatisticsEnvBase + optional + featureStatisticsEnvLog + featureStatisticsEnvINCompressor + featureStatisticsEnvFSync + featureStatisticsEnvEvictor + featureStatisticsEnvCleaner + featureStatisticsEnvCheckpointer + featureStatisticsEnvCaching + featureStatisticsDatabase + featureStatisticsLock + featureStatisticsPreload + featureStatisticsSequence + featureStatisticsTransaction + featureStatisticsBase + diff --git a/test.uvl b/test.uvl new file mode 100644 index 0000000..5d216a4 --- /dev/null +++ b/test.uvl @@ -0,0 +1,6241 @@ +features + "N_100000__F_100001" + mandatory + "N_100002__F_100003" + mandatory + "N_100002__F_100012" + alternative + "N_100002__F_100013" + mandatory + "N_100002__F_100014" + mandatory + "N_100002__F_100014_xor" {abstract} + alternative + N_100002__F_100015 + N_100002__F_100016 + "N_100002__F_100017" + alternative + N_100002__F_100018 + N_100002__F_100019 + + optional + "N_100002__F_100020" + alternative + N_100002__F_100021 + N_100002__F_100022 + N_100002__F_100023 + N_100002__F_100024 + "N_100002__F_100025" + alternative + N_100002__F_100026 + N_100002__F_100027 + N_100002__F_100028 + "N_100002__F_100029" + mandatory + "N_100002__F_100030" + alternative + N_100002__F_100031 + N_100002__F_100032 + N_100002__F_100033 + "N_100002__F_100029_or" {abstract} + or + "N_100002__F_100034" + optional + N_100002__F_100035 + "N_100002__F_100036" + or + "N_100002__I_100039_i_F_100037" + optional + N_100002__I_100039_i_F_100040 + "N_100002__I_100045_i_F_100043" + optional + N_100002__I_100045_i_F_100046 + "N_100002__I_100051_i_F_100049" + optional + N_100002__I_100051_i_F_100052 + "N_100002__I_100057_i_F_100055" + optional + N_100002__I_100057_i_F_100058 + "N_100002__I_100063_i_F_100061" + optional + N_100002__I_100063_i_F_100064 + "N_100002__I_100069_i_F_100067" + optional + N_100002__I_100069_i_F_100070 + + optional + "N_100002__F_100073" + alternative + N_100002__F_100074 + N_100002__F_100075 + N_100002__F_100076 + N_100002__F_100077 + N_100002__F_100078 + "N_100002__F_100079" + optional + "N_100002__F_100080" + alternative + N_100002__F_100081 + N_100002__F_100082 + N_100002__F_100083 + N_100002__F_100084 + N_100002__F_100085 + N_100002__F_100086 + "N_100002__F_100087" + alternative + N_100002__F_100088 + N_100002__F_100089 + N_100002__F_100090 + N_100002__F_100091 + N_100002__F_100092 + N_100002__F_100093 + N_100002__F_100094 + "N_100002__F_100095" + alternative + N_100002__F_100096 + N_100002__F_100097 + N_100002__F_100098 + N_100002__F_100099 + N_100002__F_100100 + N_100002__F_100101 + N_100002__F_100102 + N_100002__F_100103 + N_100002__F_100104 + N_100002__F_100105 + "N_100002__F_100106" + alternative + N_100002__F_100107 + N_100002__F_100108 + N_100002__F_100109 + "N_100002__F_100113" + alternative + "N_100002__F_100114" + alternative + N_100002__F_100115 + N_100002__F_100116 + N_100002__F_100117 + N_100002__F_100118 + N_100002__F_100119 + N_100002__F_100120 + N_100002__F_100121 + N_100002__F_100122 + N_100002__F_100123 + N_100002__F_100124 + N_100002__F_100125 + N_100002__F_100126 + N_100002__F_100127 + N_100002__F_100128 + N_100002__F_100129 + + optional + "N_100002__F_100004" + alternative + "N_100002__F_100005" + optional + N_100002__F_100006 + N_100002__F_100007 + N_100002__F_100008 + N_100002__F_100009 + N_100002__F_100010 + N_100002__F_100011 + "N_100002__F_100110" + optional + N_100002__F_100111 + N_100002__F_100112 + "N_100130__F_100131" + alternative + "N_100130__F_100132" + mandatory + "N_100130__F_100133" + mandatory + "N_100130__F_100134" + optional + "N_100130__F_100135" + optional + N_100130__F_100136 + N_100130__F_100137 + "N_100130__F_100138" + mandatory + N_100130__F_100139 + + optional + N_100130__F_100140 + N_100130__F_100141 + N_100130__F_100142 + N_100130__F_100143 + N_100130__F_100144 + N_100130__F_100145 + + optional + "N_100130__F_100146" + or + N_100130__F_100147 + "N_100130__F_100148" + optional + N_100130__F_100149 + N_100130__F_100150 + N_100130__F_100151 + N_100130__F_100152 + "N_100130__F_100153" + optional + N_100130__F_100154 + N_100130__F_100155 + N_100130__F_100156 + N_100130__F_100157 + N_100130__F_100158 + N_100130__F_100159 + + optional + "N_100130__F_100160" + optional + "N_100130__F_100161" + optional + N_100130__F_100162 + N_100130__F_100163 + N_100130__F_100164 + N_100130__F_100165 + N_100130__F_100166 + N_100130__F_100167 + N_100130__F_100168 + N_100130__F_100169 + "N_100130__F_100170" + optional + "N_100130__F_100171" + optional + N_100130__F_100172 + "N_100130__F_100173" + optional + "N_100130__F_100174" + or + "N_100130__F_100175" + alternative + N_100130__F_100176 + N_100130__F_100177 + N_100130__F_100178 + "N_100130__F_100179" + alternative + N_100130__F_100180 + N_100130__F_100181 + N_100130__F_100182 + "N_100130__F_100183" + alternative + N_100130__F_100184 + N_100130__F_100185 + N_100130__F_100186 + "N_100130__F_100187" + or + "N_100130__F_100188" + alternative + N_100130__F_100189 + N_100130__F_100190 + N_100130__F_100191 + "N_100130__F_100192" + alternative + N_100130__F_100193 + N_100130__F_100194 + N_100130__F_100195 + "N_100130__F_100196" + alternative + N_100130__F_100197 + N_100130__F_100198 + N_100130__F_100199 + "N_100130__F_100200" + optional + N_100130__F_100201 + "N_100130__F_100202" + alternative + "N_100130__F_100203" + mandatory + "N_100130__F_100203_xor" {abstract} + alternative + N_100130__F_100204 + N_100130__F_100205 + N_100130__F_100206 + + optional + N_100130__F_100207 + "N_100130__F_100208" + alternative + N_100130__F_100209 + N_100130__F_100210 + N_100130__F_100211 + "N_100130__F_100212" + mandatory + "N_100130__F_100212_xor" {abstract} + alternative + N_100130__F_100213 + N_100130__F_100214 + N_100130__F_100215 + + optional + N_100130__F_100216 + "N_100130__F_100217" + optional + "N_100130__F_100218" + optional + N_100130__F_100219 + N_100130__F_100220 + N_100130__F_100221 + N_100130__F_100222 + N_100130__F_100223 + N_100130__F_100224 + "N_100130__F_100225" + mandatory + "N_100130__F_100226" + alternative + N_100130__F_100227 + N_100130__F_100228 + "N_100130__F_100229" + mandatory + N_100130__F_100230 + + optional + N_100130__F_100231 + N_100130__F_100232 + + optional + N_100130__F_100233 + N_100130__F_100234 + N_100130__F_100235 + N_100130__F_100236 + N_100130__F_100237 + N_100130__F_100238 + "N_100130__F_100239" + optional + N_100130__F_100240 + N_100130__F_100241 + N_100130__F_100242 + N_100130__F_100243 + N_100130__F_100244 + N_100130__F_100245 + N_100130__F_100246 + N_100130__F_100247 + N_100130__F_100248 + N_100130__F_100249 + N_100130__F_100250 + N_100130__F_100251 + N_100130__F_100252 + "N_100130__F_100253" + mandatory + N_100130__F_100254 + N_100130__F_100255 + + optional + N_100130__F_100256 + N_100130__F_100257 + N_100130__F_100258 + N_100130__F_100259 + N_100130__F_100260 + N_100130__F_100261 + N_100130__F_100262 + N_100130__F_100263 + N_100130__F_100264 + "N_100130__F_100265" + optional + N_100130__F_100266 + N_100130__F_100267 + "N_100130__F_100268" + or + N_100130__F_100269 + N_100130__F_100270 + "N_100130__F_100271" + optional + N_100130__F_100272 + N_100130__F_100273 + N_100130__F_100274 + "N_100130__F_100275" + optional + N_100130__F_100276 + N_100130__F_100277 + N_100130__F_100278 + "N_100130__F_100279" + optional + N_100130__F_100280 + N_100130__F_100281 + "N_100130__F_100282" + optional + "N_100130__F_100283" + optional + N_100130__F_100284 + N_100130__F_100285 + "N_100130__F_100286" + optional + N_100130__F_100287 + N_100130__F_100288 + "N_100130__F_100289" + optional + N_100130__F_100290 + N_100130__F_100291 + N_100130__F_100292 + N_100130__F_100293 + N_100130__F_100294 + N_100130__F_100295 + N_100130__F_100296 + "N_100130__F_100297" + optional + N_100130__F_100298 + N_100130__F_100299 + "N_100300__F_100301" + mandatory + "N_100300__F_100302" + alternative + "N_100300__F_100303" + alternative + "N_100300__F_100304" + alternative + "N_100300__F_100305" + alternative + N_100300__F_100306 + N_100300__F_100307 + "N_100300__F_100308" + alternative + N_100300__F_100309 + N_100300__F_100310 + "N_100300__F_100311" + alternative + N_100300__F_100312 + N_100300__F_100313 + "N_100300__F_100314" + alternative + N_100300__F_100315 + N_100300__F_100316 + N_100300__F_100317 + N_100300__F_100318 + N_100300__F_100319 + N_100300__F_100320 + N_100300__F_100321 + N_100300__F_100322 + "N_100300__F_100323" + alternative + N_100300__F_100324 + "N_100300__F_100325" + mandatory + "N_100300__F_100325_xor" {abstract} + optional + N_100300__F_100326 + "N_100300__F_100327" + alternative + N_100300__F_100328 + N_100300__F_100329 + "N_100300__F_100330" + optional + N_100300__F_100331 + "N_100300__F_100332" + alternative + N_100300__F_100333 + N_100300__F_100334 + N_100300__F_100335 + "N_100300__F_100336" + alternative + N_100300__F_100337 + N_100300__F_100338 + N_100300__F_100339 + "N_100300__F_100340" + alternative + N_100300__F_100341 + N_100300__F_100342 + "N_100300__F_100343" + alternative + N_100300__F_100344 + N_100300__F_100345 + "N_100300__F_100346" + mandatory + "N_100300__F_100346_or" {abstract} + or + N_100300__F_100347 + N_100300__F_100348 + + optional + N_100300__F_100349 + + optional + "N_100300__F_100350" + alternative + N_100300__F_100351 + N_100300__F_100352 + "N_100353__F_100354" + mandatory + "N_100353__F_100358" + optional + N_100353__F_100359 + N_100353__F_100360 + N_100353__F_100361 + N_100353__F_100362 + N_100353__F_100363 + N_100353__F_100364 + N_100353__F_100365 + "N_100353__F_100366" + optional + N_100353__F_100367 + N_100353__F_100368 + N_100353__F_100369 + "N_100353__F_100370" + or + N_100353__F_100371 + N_100353__F_100372 + N_100353__F_100373 + N_100353__F_100374 + N_100353__F_100375 + N_100353__F_100376 + N_100353__F_100377 + N_100353__F_100378 + N_100353__F_100379 + "N_100353__F_100380" + or + N_100353__F_100381 + N_100353__F_100382 + N_100353__F_100383 + N_100353__F_100384 + N_100353__F_100385 + "N_100353__F_100386" + optional + N_100353__F_100387 + N_100353__F_100388 + N_100353__F_100389 + "N_100353__F_100390" + optional + "N_100353__F_100391" + or + N_100353__F_100392 + N_100353__F_100393 + "N_100353__F_100394" + or + N_100353__F_100395 + N_100353__F_100396 + "N_100353__F_100397" + or + N_100353__F_100398 + N_100353__F_100399 + "N_100353__F_100400" + or + N_100353__F_100401 + N_100353__F_100402 + N_100353__F_100403 + N_100353__F_100404 + "N_100353__F_100405" + optional + N_100353__F_100406 + "N_100353__F_100407" + optional + N_100353__F_100408 + N_100353__F_100409 + N_100353__F_100410 + N_100353__F_100411 + N_100353__F_100412 + "N_100353__F_100413" + or + N_100353__F_100414 + N_100353__F_100415 + N_100353__F_100416 + N_100353__F_100417 + N_100353__F_100418 + N_100353__F_100419 + N_100353__F_100420 + "N_100353__F_100421" + optional + N_100353__F_100422 + N_100353__F_100423 + N_100353__F_100424 + N_100353__F_100425 + N_100353__F_100426 + N_100353__F_100427 + N_100353__F_100428 + N_100353__F_100429 + N_100353__F_100430 + N_100353__F_100431 + N_100353__F_100432 + N_100353__F_100433 + N_100353__F_100434 + N_100353__F_100435 + N_100353__F_100436 + N_100353__F_100437 + N_100353__F_100438 + "N_100353__F_100439" + optional + N_100353__F_100440 + N_100353__F_100441 + N_100353__F_100442 + N_100353__F_100443 + "N_100353__F_100444" + optional + N_100353__F_100445 + "N_100353__F_100446" + optional + "N_100353__F_100447" + or + N_100353__F_100448 + N_100353__F_100449 + N_100353__F_100450 + N_100353__F_100451 + N_100353__F_100452 + N_100353__F_100453 + "N_100353__F_100454" + optional + N_100353__F_100455 + "N_100353__F_100456" + or + N_100353__F_100457 + N_100353__F_100458 + N_100353__F_100459 + N_100353__F_100460 + N_100353__F_100461 + "N_100462__F_100463" + alternative + N_100462__F_100464 + N_100462__F_100465 + N_100462__F_100466 + + optional + "N_100353__F_100355" + alternative + N_100353__F_100356 + N_100353__F_100357 + "N_100000__F_100467" + mandatory + "N_100000__F_100468" + mandatory + "N_100469__F_100470" + optional + "N_100469__I_100473_i_F_100471" + alternative + N_100469__I_100473_i_F_100474 + N_100469__I_100473_i_F_100477 + N_100469__I_100473_i_F_100480 + N_100469__I_100473_i_F_100483 + N_100469__I_100473_i_F_100486 + N_100469__I_100473_i_F_100489 + "N_100469__I_100494_i_F_100492" + mandatory + "N_100469__I_100494_i_F_100495" + or + N_100469__I_100494_i_F_100498 + N_100469__I_100494_i_F_100501 + "N_100469__I_100506_i_F_100504" + mandatory + "N_100469__I_100506_i_F_100507" + or + N_100469__I_100506_i_F_100510 + N_100469__I_100506_i_F_100513 + "N_100469__I_100518_i_F_100516" + mandatory + "N_100469__I_100518_i_F_100519" + or + N_100469__I_100518_i_F_100522 + N_100469__I_100518_i_F_100525 + "N_100469__I_100530_i_F_100528" + mandatory + "N_100469__I_100530_i_F_100531" + or + N_100469__I_100530_i_F_100534 + N_100469__I_100530_i_F_100537 + "N_100469__I_100542_i_F_100540" + mandatory + "N_100469__I_100542_i_F_100543" + or + N_100469__I_100542_i_F_100546 + N_100469__I_100542_i_F_100549 + "N_100469__I_100554_i_F_100552" + mandatory + "N_100469__I_100554_i_F_100555" + or + N_100469__I_100554_i_F_100558 + N_100469__I_100554_i_F_100561 + "N_100469__I_100566_i_F_100564" + mandatory + "N_100469__I_100566_i_F_100567" + or + N_100469__I_100566_i_F_100570 + N_100469__I_100566_i_F_100573 + "N_100576__F_100577" + mandatory + "N_100576__F_100578" + alternative + N_100576__F_100579 + N_100576__F_100580 + N_100576__F_100581 + N_100576__F_100582 + N_100576__F_100583 + N_100576__F_100584 + N_100576__F_100585 + N_100576__F_100586 + N_100576__F_100587 + "N_100576__F_100588" + mandatory + "N_100576__F_100589" + alternative + N_100576__F_100590 + N_100576__F_100591 + "N_100576__F_100592" + alternative + N_100576__F_100593 + N_100576__F_100594 + "N_100576__F_100595" + alternative + N_100576__F_100596 + N_100576__F_100597 + N_100576__F_100598 + "N_100576__F_100599" + alternative + N_100576__F_100600 + N_100576__F_100601 + N_100576__F_100602 + "N_100576__F_100603" + alternative + N_100576__F_100604 + N_100576__F_100605 + "N_100469__I_100608_i_F_100606" + mandatory + "N_100469__I_100608_i_F_100609" + or + N_100469__I_100608_i_F_100612 + N_100469__I_100608_i_F_100615 + "N_100618__F_100619" + optional + "N_100618__F_100620" + mandatory + "N_100618__F_100621" + alternative + N_100618__I_100624_i_F_100622 + N_100618__F_100625 + "N_100618__F_100626" + mandatory + "N_100618__I_100629_i_F_100627" + alternative + N_100618__I_100629_i_F_100630 + N_100618__I_100629_i_F_100633 + N_100618__I_100629_i_F_100636 + N_100618__I_100629_i_F_100639 + N_100618__I_100629_i_F_100642 + N_100618__I_100629_i_F_100645 + "N_100618__F_100648" + mandatory + "N_100618__F_100649" + or + "N_100618__I_100652_i_F_100650" + alternative + N_100618__I_100652_i_F_100653 + N_100618__I_100652_i_F_100656 + N_100618__I_100652_i_F_100659 + N_100618__I_100652_i_F_100662 + N_100618__I_100652_i_F_100665 + N_100618__I_100652_i_F_100668 + N_100618__I_100673_i_F_100671 + "N_100618__F_100674" + mandatory + "N_100618__I_100677_i_F_100675" + alternative + N_100618__I_100677_i_F_100678 + N_100618__I_100677_i_F_100681 + N_100618__I_100677_i_F_100684 + N_100618__I_100677_i_F_100687 + N_100618__I_100677_i_F_100690 + N_100618__I_100677_i_F_100693 + + optional + N_100618__F_100696 + N_100618__F_100697 + N_100618__F_100698 + N_100618__F_100699 + N_100618__F_100700 + N_100618__F_100701 + N_100618__F_100702 + N_100618__F_100703 + N_100618__F_100704 + N_100618__F_100705 + N_100618__F_100706 + N_100618__F_100707 + N_100618__F_100708 + N_100618__F_100709 + "N_100618__F_100710" + mandatory + "N_100618__I_100713_i_F_100711" + alternative + N_100618__I_100713_i_F_100714 + N_100618__I_100713_i_F_100717 + N_100618__I_100713_i_F_100720 + N_100618__I_100713_i_F_100723 + N_100618__I_100713_i_F_100726 + N_100618__I_100713_i_F_100729 + "N_100618__F_100732" + mandatory + "N_100618__I_100735_i_F_100733" + alternative + N_100618__I_100735_i_F_100736 + N_100618__I_100735_i_F_100739 + N_100618__I_100735_i_F_100742 + N_100618__I_100735_i_F_100745 + N_100618__I_100735_i_F_100748 + N_100618__I_100735_i_F_100751 + + optional + N_100618__F_100754 + N_100618__F_100755 + N_100618__F_100756 + N_100618__F_100757 + N_100618__F_100758 + "N_100618__F_100759" + mandatory + "N_100618__I_100762_i_F_100760" + alternative + N_100618__I_100762_i_F_100763 + N_100618__I_100762_i_F_100766 + N_100618__I_100762_i_F_100769 + N_100618__I_100762_i_F_100772 + N_100618__I_100762_i_F_100775 + N_100618__I_100762_i_F_100778 + + optional + N_100618__F_100781 + N_100618__F_100782 + N_100618__F_100783 + N_100618__F_100784 + N_100618__F_100785 + N_100618__F_100786 + N_100618__F_100787 + N_100618__F_100788 + N_100618__F_100789 + "N_100618__F_100790" + mandatory + "N_100618__I_100793_i_F_100791" + alternative + N_100618__I_100793_i_F_100794 + N_100618__I_100793_i_F_100797 + N_100618__I_100793_i_F_100800 + N_100618__I_100793_i_F_100803 + N_100618__I_100793_i_F_100806 + N_100618__I_100793_i_F_100809 + + optional + N_100618__F_100812 + N_100618__F_100813 + N_100618__F_100814 + N_100618__F_100815 + N_100618__F_100816 + N_100618__F_100817 + N_100618__F_100818 + N_100618__F_100819 + "N_100618__F_100820" + mandatory + "N_100618__I_100823_i_F_100821" + alternative + N_100618__I_100823_i_F_100824 + N_100618__I_100823_i_F_100827 + N_100618__I_100823_i_F_100830 + N_100618__I_100823_i_F_100833 + N_100618__I_100823_i_F_100836 + N_100618__I_100823_i_F_100839 + + optional + N_100618__F_100842 + N_100618__F_100843 + "N_100618__F_100844" + mandatory + "N_100618__I_100847_i_F_100845" + alternative + N_100618__I_100847_i_F_100848 + N_100618__I_100847_i_F_100851 + N_100618__I_100847_i_F_100854 + N_100618__I_100847_i_F_100857 + N_100618__I_100847_i_F_100860 + N_100618__I_100847_i_F_100863 + + optional + N_100618__F_100866 + N_100618__F_100867 + N_100618__F_100868 + "N_100618__F_100869" + mandatory + N_100618__I_100872_i_F_100870 + "N_100000__F_100873" + mandatory + "N_100000__F_100874" + mandatory + "N_100000__I_100877_i_F_100875" + mandatory + "N_100000__I_100877_i_F_100878" + alternative + N_100000__I_100877_i_F_100881 + N_100000__I_100877_i_F_100884 + N_100000__I_100877_i_F_100887 + N_100000__I_100877_i_F_100890 + N_100000__I_100877_i_F_100893 + N_100000__I_100877_i_F_100896 + N_100000__I_100877_i_F_100899 + N_100000__I_100877_i_F_100902 + N_100000__I_100877_i_F_100905 + N_100000__I_100877_i_F_100908 + "N_100000__I_100877_i_F_100911" + alternative + N_100000__I_100877_i_F_100914 + "N_100000__I_100877_i_F_100917" + alternative + N_100000__I_100877_i_F_100920 + N_100000__I_100877_i_F_100923 + N_100000__I_100877_i_F_100926 + N_100000__I_100877_i_F_100929 + N_100000__I_100877_i_F_100932 + N_100000__I_100877_i_F_100935 + N_100000__I_100877_i_F_100938 + N_100000__I_100877_i_F_100941 + "N_100000__I_100877_i_F_100944" + alternative + N_100000__I_100877_i_F_100947 + N_100000__I_100877_i_F_100950 + "N_100000__I_100877_i_F_100962" + alternative + N_100000__I_100877_i_F_100965 + N_100000__I_100877_i_F_100968 + N_100000__I_100877_i_F_100971 + + optional + N_100000__I_100877_i_F_100953 + N_100000__I_100877_i_F_100956 + N_100000__I_100877_i_F_100959 + "N_100000__I_101075_i_F_101073" + mandatory + "N_100000__I_101075_i_F_101076" + alternative + N_100000__I_101075_i_F_101079 + N_100000__I_101075_i_F_101082 + N_100000__I_101075_i_F_101085 + N_100000__I_101075_i_F_101088 + N_100000__I_101075_i_F_101091 + N_100000__I_101075_i_F_101094 + N_100000__I_101075_i_F_101097 + N_100000__I_101075_i_F_101100 + N_100000__I_101075_i_F_101103 + N_100000__I_101075_i_F_101106 + "N_100000__I_101075_i_F_101109" + alternative + N_100000__I_101075_i_F_101112 + "N_100000__I_101075_i_F_101115" + alternative + N_100000__I_101075_i_F_101118 + N_100000__I_101075_i_F_101121 + N_100000__I_101075_i_F_101124 + N_100000__I_101075_i_F_101127 + N_100000__I_101075_i_F_101130 + N_100000__I_101075_i_F_101133 + N_100000__I_101075_i_F_101136 + N_100000__I_101075_i_F_101139 + "N_100000__I_101075_i_F_101142" + alternative + N_100000__I_101075_i_F_101145 + N_100000__I_101075_i_F_101148 + "N_100000__I_101075_i_F_101160" + alternative + N_100000__I_101075_i_F_101163 + N_100000__I_101075_i_F_101166 + N_100000__I_101075_i_F_101169 + + optional + N_100000__I_101075_i_F_101151 + N_100000__I_101075_i_F_101154 + N_100000__I_101075_i_F_101157 + + optional + "N_100000__I_100976_i_F_100974" + mandatory + "N_100000__I_100976_i_F_100977" + alternative + N_100000__I_100976_i_F_100980 + N_100000__I_100976_i_F_100983 + N_100000__I_100976_i_F_100986 + N_100000__I_100976_i_F_100989 + N_100000__I_100976_i_F_100992 + N_100000__I_100976_i_F_100995 + N_100000__I_100976_i_F_100998 + N_100000__I_100976_i_F_101001 + N_100000__I_100976_i_F_101004 + N_100000__I_100976_i_F_101007 + "N_100000__I_100976_i_F_101010" + alternative + N_100000__I_100976_i_F_101013 + "N_100000__I_100976_i_F_101016" + alternative + N_100000__I_100976_i_F_101019 + N_100000__I_100976_i_F_101022 + N_100000__I_100976_i_F_101025 + N_100000__I_100976_i_F_101028 + N_100000__I_100976_i_F_101031 + N_100000__I_100976_i_F_101034 + N_100000__I_100976_i_F_101037 + N_100000__I_100976_i_F_101040 + "N_100000__I_100976_i_F_101043" + alternative + N_100000__I_100976_i_F_101046 + N_100000__I_100976_i_F_101049 + "N_100000__I_100976_i_F_101061" + alternative + N_100000__I_100976_i_F_101064 + N_100000__I_100976_i_F_101067 + N_100000__I_100976_i_F_101070 + + optional + N_100000__I_100976_i_F_101052 + N_100000__I_100976_i_F_101055 + N_100000__I_100976_i_F_101058 + "N_100000__I_101174_i_F_101172" + mandatory + "N_100000__I_101174_i_F_101175" + alternative + N_100000__I_101174_i_F_101178 + N_100000__I_101174_i_F_101181 + N_100000__I_101174_i_F_101184 + N_100000__I_101174_i_F_101187 + N_100000__I_101174_i_F_101190 + N_100000__I_101174_i_F_101193 + N_100000__I_101174_i_F_101196 + N_100000__I_101174_i_F_101199 + N_100000__I_101174_i_F_101202 + N_100000__I_101174_i_F_101205 + "N_100000__I_101174_i_F_101208" + alternative + N_100000__I_101174_i_F_101211 + "N_100000__I_101174_i_F_101214" + alternative + N_100000__I_101174_i_F_101217 + N_100000__I_101174_i_F_101220 + N_100000__I_101174_i_F_101223 + N_100000__I_101174_i_F_101226 + N_100000__I_101174_i_F_101229 + N_100000__I_101174_i_F_101232 + N_100000__I_101174_i_F_101235 + N_100000__I_101174_i_F_101238 + "N_100000__I_101174_i_F_101241" + alternative + N_100000__I_101174_i_F_101244 + N_100000__I_101174_i_F_101247 + "N_100000__I_101174_i_F_101259" + alternative + N_100000__I_101174_i_F_101262 + N_100000__I_101174_i_F_101265 + N_100000__I_101174_i_F_101268 + + optional + N_100000__I_101174_i_F_101250 + N_100000__I_101174_i_F_101253 + N_100000__I_101174_i_F_101256 + N_100000__F_101271 + N_100000__F_101272 + + optional + "N_100000__F_101273" + mandatory + "N_100000__F_101274" + alternative + N_100000__F_101275 + N_100000__F_101276 + N_100000__F_101277 + N_100000__F_101278 + N_100000__F_101279 + N_100000__F_101280 + N_100000__F_101281 + N_100000__F_101282 + "N_100000__I_101285_i_F_101283" + mandatory + "N_100000__I_101285_i_F_101286" + alternative + N_100000__I_101285_i_F_101289 + N_100000__I_101285_i_F_101292 + "N_100000__I_101285_i_F_101295" + optional + N_100000__I_101285_i_F_101298 + "N_100000__I_101285_i_F_101301" + alternative + N_100000__I_101285_i_F_101304 + N_100000__I_101285_i_F_101307 + "N_100000__I_101285_i_F_101310" + optional + N_100000__I_101285_i_F_101313 + "N_100000__I_101285_i_F_101316" + mandatory + "N_100000__I_101285_i_F_101319" + alternative + N_100000__I_101285_i_F_101322 + N_100000__I_101285_i_F_101325 + N_100000__I_101285_i_F_101328 + N_100000__I_101285_i_F_101331 + "N_100000__I_101285_i_F_101316_xor" {abstract} + alternative + "N_100000__I_101285_i_F_101334" + alternative + N_100000__I_101285_i_F_101337 + N_100000__I_101285_i_F_101340 + "N_100000__I_101285_i_F_101343" + alternative + N_100000__I_101285_i_F_101346 + N_100000__I_101285_i_F_101349 + N_100000__I_101285_i_F_101352 + N_100000__I_101285_i_F_101355 + N_100000__I_101285_i_F_101358 + "N_100000__I_101285_i_F_101361" + alternative + N_100000__I_101285_i_F_101364 + N_100000__I_101285_i_F_101367 + N_100000__I_101285_i_F_101370 + N_100000__I_101285_i_F_101373 + N_100000__I_101285_i_F_101376 + N_100000__I_101285_i_F_101379 + N_100000__I_101285_i_F_101382 + N_100000__I_101285_i_F_101385 + "N_100000__I_101285_i_F_101388" + alternative + N_100000__I_101285_i_F_101391 + N_100000__I_101285_i_F_101394 + N_100000__I_101285_i_F_101397 + N_100000__I_101285_i_F_101400 + + optional + "N_100000__I_101405_i_F_101403" + mandatory + "N_100000__I_101405_i_F_101406" + alternative + N_100000__I_101405_i_F_101409 + N_100000__I_101405_i_F_101412 + "N_100000__I_101405_i_F_101415" + optional + N_100000__I_101405_i_F_101418 + "N_100000__I_101405_i_F_101421" + alternative + N_100000__I_101405_i_F_101424 + N_100000__I_101405_i_F_101427 + "N_100000__I_101405_i_F_101430" + optional + N_100000__I_101405_i_F_101433 + "N_100000__I_101405_i_F_101436" + mandatory + "N_100000__I_101405_i_F_101439" + alternative + N_100000__I_101405_i_F_101442 + N_100000__I_101405_i_F_101445 + N_100000__I_101405_i_F_101448 + N_100000__I_101405_i_F_101451 + "N_100000__I_101405_i_F_101436_xor" {abstract} + alternative + "N_100000__I_101405_i_F_101454" + alternative + N_100000__I_101405_i_F_101457 + N_100000__I_101405_i_F_101460 + "N_100000__I_101405_i_F_101463" + alternative + N_100000__I_101405_i_F_101466 + N_100000__I_101405_i_F_101469 + N_100000__I_101405_i_F_101472 + N_100000__I_101405_i_F_101475 + N_100000__I_101405_i_F_101478 + "N_100000__I_101405_i_F_101481" + alternative + N_100000__I_101405_i_F_101484 + N_100000__I_101405_i_F_101487 + N_100000__I_101405_i_F_101490 + N_100000__I_101405_i_F_101493 + N_100000__I_101405_i_F_101496 + N_100000__I_101405_i_F_101499 + N_100000__I_101405_i_F_101502 + N_100000__I_101405_i_F_101505 + "N_100000__I_101405_i_F_101508" + alternative + N_100000__I_101405_i_F_101511 + N_100000__I_101405_i_F_101514 + N_100000__I_101405_i_F_101517 + N_100000__I_101405_i_F_101520 + "N_100000__I_101525_i_F_101523" + mandatory + "N_100000__I_101525_i_F_101526" + alternative + N_100000__I_101525_i_F_101529 + N_100000__I_101525_i_F_101532 + "N_100000__I_101525_i_F_101535" + optional + N_100000__I_101525_i_F_101538 + "N_100000__I_101525_i_F_101541" + alternative + N_100000__I_101525_i_F_101544 + N_100000__I_101525_i_F_101547 + "N_100000__I_101525_i_F_101550" + optional + N_100000__I_101525_i_F_101553 + "N_100000__I_101525_i_F_101556" + mandatory + "N_100000__I_101525_i_F_101559" + alternative + N_100000__I_101525_i_F_101562 + N_100000__I_101525_i_F_101565 + N_100000__I_101525_i_F_101568 + N_100000__I_101525_i_F_101571 + "N_100000__I_101525_i_F_101556_xor" {abstract} + alternative + "N_100000__I_101525_i_F_101574" + alternative + N_100000__I_101525_i_F_101577 + N_100000__I_101525_i_F_101580 + "N_100000__I_101525_i_F_101583" + alternative + N_100000__I_101525_i_F_101586 + N_100000__I_101525_i_F_101589 + N_100000__I_101525_i_F_101592 + N_100000__I_101525_i_F_101595 + N_100000__I_101525_i_F_101598 + "N_100000__I_101525_i_F_101601" + alternative + N_100000__I_101525_i_F_101604 + N_100000__I_101525_i_F_101607 + N_100000__I_101525_i_F_101610 + N_100000__I_101525_i_F_101613 + N_100000__I_101525_i_F_101616 + N_100000__I_101525_i_F_101619 + N_100000__I_101525_i_F_101622 + N_100000__I_101525_i_F_101625 + "N_100000__I_101525_i_F_101628" + alternative + N_100000__I_101525_i_F_101631 + N_100000__I_101525_i_F_101634 + N_100000__I_101525_i_F_101637 + N_100000__I_101525_i_F_101640 + "N_100000__I_101645_i_F_101643" + mandatory + "N_100000__I_101645_i_F_101646" + alternative + N_100000__I_101645_i_F_101649 + N_100000__I_101645_i_F_101652 + "N_100000__I_101645_i_F_101655" + optional + N_100000__I_101645_i_F_101658 + "N_100000__I_101645_i_F_101661" + alternative + N_100000__I_101645_i_F_101664 + N_100000__I_101645_i_F_101667 + "N_100000__I_101645_i_F_101670" + optional + N_100000__I_101645_i_F_101673 + "N_100000__I_101645_i_F_101676" + mandatory + "N_100000__I_101645_i_F_101679" + alternative + N_100000__I_101645_i_F_101682 + N_100000__I_101645_i_F_101685 + N_100000__I_101645_i_F_101688 + N_100000__I_101645_i_F_101691 + "N_100000__I_101645_i_F_101676_xor" {abstract} + alternative + "N_100000__I_101645_i_F_101694" + alternative + N_100000__I_101645_i_F_101697 + N_100000__I_101645_i_F_101700 + "N_100000__I_101645_i_F_101703" + alternative + N_100000__I_101645_i_F_101706 + N_100000__I_101645_i_F_101709 + N_100000__I_101645_i_F_101712 + N_100000__I_101645_i_F_101715 + N_100000__I_101645_i_F_101718 + "N_100000__I_101645_i_F_101721" + alternative + N_100000__I_101645_i_F_101724 + N_100000__I_101645_i_F_101727 + N_100000__I_101645_i_F_101730 + N_100000__I_101645_i_F_101733 + N_100000__I_101645_i_F_101736 + N_100000__I_101645_i_F_101739 + N_100000__I_101645_i_F_101742 + N_100000__I_101645_i_F_101745 + "N_100000__I_101645_i_F_101748" + alternative + N_100000__I_101645_i_F_101751 + N_100000__I_101645_i_F_101754 + N_100000__I_101645_i_F_101757 + N_100000__I_101645_i_F_101760 + N_100000__F_101763 + "N_101764__F_101765" + mandatory + "N_101764__F_101766" + alternative + N_101764__F_101767 + N_101764__F_101768 + N_101764__F_101769 + N_101764__F_101770 + N_101764__F_101771 + N_101764__F_101772 + N_101764__F_101773 + N_101764__F_101774 + N_101764__F_101775 + N_101764__F_101776 + N_101764__F_101777 + N_101764__F_101778 + N_101764__F_101779 + N_101764__F_101780 + N_101764__F_101781 + N_101764__F_101782 + "N_101764__F_101783" + alternative + "N_101764__F_101784" + mandatory + "N_101764__F_101784_xor" {abstract} + optional + "N_101764__F_101785" + alternative + N_101764__F_101786 + N_101764__F_101787 + N_101764__F_101788 + N_101764__F_101789 + N_101764__F_101790 + N_101764__F_101791 + + optional + N_101764__F_101792 + "N_101764__F_101793" + alternative + "N_101764__F_101794" + mandatory + "N_101764__F_101795" + alternative + N_101764__F_101796 + N_101764__F_101797 + "N_101764__F_101798" + mandatory + "N_101764__F_101799" + alternative + N_101764__F_101800 + N_101764__F_101801 + N_101764__F_101802 + N_101764__F_101803 + N_101764__F_101804 + N_101764__F_101805 + N_101764__F_101806 + "N_101764__F_101807" + mandatory + "N_101764__F_101808" + optional + N_101764__F_101809 + "N_101764__F_101810" + alternative + "N_101764__F_101811" + alternative + N_101764__F_101812 + N_101764__F_101813 + "N_101764__I_101816_i_F_101814" + alternative + N_101764__I_101816_i_F_101817 + N_101764__I_101816_i_F_101820 + N_101764__I_101816_i_F_101823 + N_101764__I_101816_i_F_101826 + N_101764__I_101816_i_F_101829 + N_101764__I_101816_i_F_101832 + "N_101764__F_101835" + or + "N_101764__F_101836" + mandatory + "N_101764__I_101839_i_F_101837" + or + N_101764__I_101839_i_F_101840 + N_101764__I_101839_i_F_101843 + "N_101764__F_101846" + mandatory + "N_101764__I_101849_i_F_101847" + or + N_101764__I_101849_i_F_101850 + N_101764__I_101849_i_F_101853 + "N_101764__F_101856" + mandatory + "N_101764__I_101859_i_F_101857" + or + N_101764__I_101859_i_F_101860 + N_101764__I_101859_i_F_101863 + "N_101764__F_101866" + or + "N_101764__F_101867" + mandatory + "N_101764__I_101870_i_F_101868" + or + N_101764__I_101870_i_F_101871 + N_101764__I_101870_i_F_101874 + N_101764__I_101870_i_F_101877 + "N_101764__F_101880" + mandatory + "N_101764__I_101883_i_F_101881" + or + N_101764__I_101883_i_F_101884 + N_101764__I_101883_i_F_101887 + N_101764__I_101883_i_F_101890 + "N_101764__F_101893" + mandatory + "N_101764__I_101896_i_F_101894" + or + N_101764__I_101896_i_F_101897 + N_101764__I_101896_i_F_101900 + N_101764__I_101896_i_F_101903 + "N_101906__F_101907" + mandatory + "N_101906__F_101908" + alternative + N_101906__F_101909 + N_101906__F_101910 + N_101906__F_101911 + "N_101906__F_101912" + alternative + N_101906__F_101913 + N_101906__F_101914 + "N_101906__F_101915" + alternative + N_101906__F_101916 + N_101906__F_101917 + N_101906__F_101918 + "N_101906__F_101919" + alternative + N_101906__F_101920 + N_101906__F_101921 + "N_101906__F_101922" + alternative + "N_101906__F_101923" + optional + "N_101906__F_101924" + optional + N_101906__F_101925 + N_101906__F_101926 + + optional + "N_101906__F_101927" + optional + N_101906__F_101928 + "N_101906__F_101929" + or + N_101906__F_101930 + N_101906__F_101931 + "N_101932__F_101933" + mandatory + "N_101932__F_101934" + alternative + N_101932__F_101935 + N_101932__F_101936 + N_101932__F_101937 + N_101932__F_101938 + N_101932__F_101939 + N_101932__F_101940 + N_101932__F_101941 + N_101932__F_101942 + N_101932__F_101943 + N_101932__F_101944 + N_101932__F_101945 + "N_101932__F_101946" + alternative + "N_101932__F_101947" + or + N_101932__F_101948 + N_101932__F_101949 + N_101932__F_101950 + N_101932__F_101951 + "N_101932__F_101952" + optional + N_101932__F_101953 + "N_101932__F_101954" + or + N_101932__F_101955 + N_101932__F_101956 + N_101932__F_101957 + N_101932__F_101958 + N_101932__F_101959 + N_101932__F_101960 + N_101932__F_101961 + N_101932__F_101962 + N_101932__F_101963 + "N_101932__F_101964" + mandatory + "N_101932__I_101967_i_F_101965" + alternative + N_101932__I_101967_i_F_101968 + N_101932__I_101967_i_F_101971 + N_101932__I_101967_i_F_101974 + N_101932__I_101967_i_F_101977 + N_101932__I_101967_i_F_101980 + N_101932__I_101967_i_F_101983 + "N_101932__F_101990" + mandatory + "N_101932__I_101993_i_F_101991" + or + N_101932__I_101993_i_F_101994 + N_101932__I_101993_i_F_101997 + N_101932__I_101993_i_F_102000 + + optional + "N_101932__F_101986" + optional + "N_101932__F_101987" + alternative + N_101932__F_101988 + N_101932__F_101989 + N_100000__F_102003 + "N_102004__F_102005" + mandatory + "N_102004__F_102006" + alternative + N_102004__F_102007 + N_102004__F_102008 + N_102004__F_102009 + "N_102004__F_102010" + mandatory + "N_102004__F_102011" + alternative + N_102004__F_102012 + "N_102004__F_102013" + optional + "N_102004__F_102014" + optional + N_102004__F_102015 + "N_102004__F_102016" + optional + N_102004__F_102017 + "N_102004__F_102018" + optional + "N_102004__F_102019" + optional + N_102004__F_102020 + + optional + "N_102004__F_102021" + optional + N_102004__F_102022 + "N_102004__F_102023" + alternative + N_102004__F_102024 + N_102004__F_102025 + "N_102026__F_102027" + mandatory + "N_102026__F_102029" + optional + N_102026__F_102030 + N_102026__F_102031 + N_102026__F_102032 + "N_102026__F_102038" + optional + N_102026__F_102039 + N_102026__F_102040 + N_102026__F_102041 + + optional + N_102026__F_102028 + "N_102026__F_102033" + mandatory + "N_102026__F_102033_xor" {abstract} + alternative + N_102026__F_102034 + N_102026__F_102035 + N_102026__F_102036 + + optional + N_102026__F_102037 + "N_100000__F_102042" + mandatory + "N_102043__F_102044" + mandatory + "N_102043__F_102044_or" {abstract} + optional + "N_102043__F_102050" + mandatory + "N_102043__I_102053_i_F_102051" + alternative + N_102043__I_102053_i_F_102054 + N_102043__I_102053_i_F_102057 + N_102043__I_102053_i_F_102060 + N_102043__I_102053_i_F_102063 + N_102043__I_102053_i_F_102066 + N_102043__I_102053_i_F_102069 + "N_102043__I_102076_i_F_102074" + mandatory + "N_102043__I_102076_i_F_102077" + alternative + N_102043__I_102076_i_F_102080 + N_102043__I_102076_i_F_102083 + "N_102043__I_102088_i_F_102086" + mandatory + "N_102043__I_102088_i_F_102089" + alternative + N_102043__I_102088_i_F_102092 + N_102043__I_102088_i_F_102095 + + optional + N_102043__F_102072 + N_102043__F_102073 + "N_102043__I_102100_i_F_102098" + mandatory + "N_102043__I_102100_i_F_102101" + alternative + N_102043__I_102100_i_F_102104 + N_102043__I_102100_i_F_102107 + "N_102043__I_102112_i_F_102110" + mandatory + "N_102043__I_102112_i_F_102113" + alternative + N_102043__I_102112_i_F_102116 + N_102043__I_102112_i_F_102119 + "N_102043__I_102124_i_F_102122" + mandatory + "N_102043__I_102124_i_F_102125" + alternative + N_102043__I_102124_i_F_102128 + N_102043__I_102124_i_F_102131 + "N_102043__I_102136_i_F_102134" + mandatory + "N_102043__I_102136_i_F_102137" + alternative + N_102043__I_102136_i_F_102140 + N_102043__I_102136_i_F_102143 + "N_102043__I_102148_i_F_102146" + mandatory + "N_102043__I_102148_i_F_102149" + alternative + N_102043__I_102148_i_F_102152 + N_102043__I_102148_i_F_102155 + "N_102043__I_102160_i_F_102158" + mandatory + "N_102043__I_102160_i_F_102161" + alternative + N_102043__I_102160_i_F_102164 + N_102043__I_102160_i_F_102167 + "N_102043__I_102172_i_F_102170" + mandatory + "N_102043__I_102172_i_F_102173" + alternative + N_102043__I_102172_i_F_102176 + N_102043__I_102172_i_F_102179 + "N_102043__I_102184_i_F_102182" + mandatory + "N_102043__I_102184_i_F_102185" + alternative + N_102043__I_102184_i_F_102188 + N_102043__I_102184_i_F_102191 + + optional + "N_102043__F_102045" + optional + N_102043__F_102046 + N_102043__F_102047 + N_102043__F_102048 + N_102043__F_102049 + "N_102043__F_102194" + mandatory + "N_102043__I_102197_i_F_102195" + mandatory + "N_102043__I_102197_i_F_102198" + alternative + N_102043__I_102197_i_F_102201 + N_102043__I_102197_i_F_102204 + + optional + N_102043__F_102207 + "N_102043__F_102208" + mandatory + "N_102043__I_102211_i_F_102209" + alternative + N_102043__I_102211_i_F_102212 + N_102043__I_102211_i_F_102215 + N_102043__I_102211_i_F_102218 + N_102043__I_102211_i_F_102221 + N_102043__I_102211_i_F_102224 + N_102043__I_102211_i_F_102227 + + optional + "N_102043__F_102230" + alternative + N_102043__I_102233_i_F_102231 + N_102043__F_102234 + N_102043__F_102235 + N_102043__F_102236 + "N_102043__F_102237" + mandatory + "N_102043__I_102240_i_F_102238" + alternative + N_102043__I_102240_i_F_102241 + N_102043__I_102240_i_F_102244 + N_102043__I_102240_i_F_102247 + N_102043__I_102240_i_F_102250 + N_102043__I_102240_i_F_102253 + N_102043__I_102240_i_F_102256 + "N_102043__F_102259" + mandatory + "N_102043__I_102262_i_F_102260" + alternative + N_102043__I_102262_i_F_102263 + N_102043__I_102262_i_F_102266 + N_102043__I_102262_i_F_102269 + N_102043__I_102262_i_F_102272 + N_102043__I_102262_i_F_102275 + N_102043__I_102262_i_F_102278 + + optional + N_102043__F_102281 + N_102043__F_102282 + "N_102043__F_102283" + mandatory + "N_102043__I_102286_i_F_102284" + alternative + N_102043__I_102286_i_F_102287 + N_102043__I_102286_i_F_102290 + N_102043__I_102286_i_F_102293 + N_102043__I_102286_i_F_102296 + N_102043__I_102286_i_F_102299 + N_102043__I_102286_i_F_102302 + + optional + N_102043__F_102305 + N_102043__F_102306 + N_102043__F_102307 + N_102043__F_102308 + N_102043__F_102309 + N_102043__F_102310 + "N_102043__F_102311" + mandatory + "N_102043__I_102314_i_F_102312" + alternative + N_102043__I_102314_i_F_102315 + N_102043__I_102314_i_F_102318 + N_102043__I_102314_i_F_102321 + N_102043__I_102314_i_F_102324 + N_102043__I_102314_i_F_102327 + N_102043__I_102314_i_F_102330 + "N_102043__F_102333" + mandatory + "N_102043__I_102336_i_F_102334" + alternative + N_102043__I_102336_i_F_102337 + N_102043__I_102336_i_F_102340 + N_102043__I_102336_i_F_102343 + N_102043__I_102336_i_F_102346 + N_102043__I_102336_i_F_102349 + N_102043__I_102336_i_F_102352 + + optional + N_102043__F_102355 + "N_102043__F_102356" + mandatory + "N_102043__I_102359_i_F_102357" + alternative + N_102043__I_102359_i_F_102360 + N_102043__I_102359_i_F_102363 + N_102043__I_102359_i_F_102366 + N_102043__I_102359_i_F_102369 + N_102043__I_102359_i_F_102372 + N_102043__I_102359_i_F_102375 + + optional + N_102043__F_102378 + N_102043__F_102379 + N_102043__F_102380 + N_102043__F_102381 + "N_100000__F_102382" + mandatory + "N_100000__F_102382_xor" {abstract} + alternative + "N_102383__F_102384" + mandatory + "N_102385__F_102386" + mandatory + "N_102385__F_102405" + mandatory + "N_102385__F_102406" + alternative + N_102385__F_102407 + N_102385__F_102408 + N_102385__F_102409 + N_102385__F_102410 + N_102385__F_102411 + N_102385__F_102412 + N_102385__F_102413 + N_102385__F_102414 + N_102385__F_102415 + N_102385__F_102416 + N_102385__F_102417 + N_102385__F_102418 + "N_102385__F_102419" + alternative + N_102385__F_102420 + N_102385__F_102421 + N_102385__F_102422 + "N_102385__F_102423" + mandatory + "N_102385__F_102424" + mandatory + "N_102385__F_102425" + alternative + N_102385__F_102426 + N_102385__F_102427 + N_102385__F_102428 + N_102385__F_102429 + N_102385__F_102430 + N_102385__F_102431 + N_102385__F_102432 + "N_102385__F_102433" + alternative + N_102385__F_102434 + N_102385__F_102435 + N_102385__F_102436 + N_102385__F_102437 + "N_102385__F_102438" + alternative + N_102385__F_102439 + N_102385__F_102440 + N_102385__F_102441 + N_102385__F_102442 + "N_102385__F_102443" + alternative + N_102385__F_102444 + N_102385__F_102445 + "N_102385__F_102446" + alternative + N_102385__F_102447 + N_102385__F_102448 + N_102385__F_102449 + N_102385__F_102450 + N_102385__F_102451 + "N_102385__F_102452" + alternative + N_102385__F_102453 + N_102385__F_102454 + "N_102385__F_102455" + mandatory + "N_102385__F_102456" + mandatory + "N_102385__F_102456_xor" {abstract} + alternative + N_102385__F_102457 + N_102385__F_102458 + N_102385__F_102459 + N_102385__F_102460 + N_102385__F_102461 + N_102385__F_102462 + N_102385__F_102463 + + optional + N_102385__F_102464 + "N_102385__F_102465" + alternative + N_102385__F_102466 + N_102385__F_102467 + N_102385__F_102468 + "N_102385__F_102469" + alternative + N_102385__F_102470 + N_102385__F_102471 + N_102385__F_102472 + N_102385__F_102473 + N_102385__F_102474 + "N_102385__F_102475" + alternative + N_102385__F_102476 + N_102385__F_102477 + N_102385__F_102478 + N_102385__F_102479 + "N_102385__F_102480" + mandatory + "N_102385__F_102480_xor" {abstract} + alternative + N_102385__F_102481 + N_102385__F_102482 + + optional + "N_102385__F_102483" + alternative + N_102385__F_102484 + N_102385__F_102485 + N_102385__F_102486 + "N_102385__F_102489" + mandatory + "N_102385__F_102490" + alternative + N_102385__F_102491 + N_102385__F_102492 + N_102385__F_102493 + N_102385__F_102494 + N_102385__F_102495 + N_102385__F_102496 + N_102385__F_102497 + N_102385__F_102498 + N_102385__F_102499 + + optional + N_102385__F_102500 + + optional + "N_102385__F_102387" + alternative + N_102385__F_102388 + N_102385__F_102389 + N_102385__F_102390 + N_102385__F_102391 + N_102385__F_102392 + N_102385__F_102393 + N_102385__F_102394 + N_102385__F_102395 + N_102385__F_102396 + N_102385__F_102397 + N_102385__F_102398 + N_102385__F_102399 + N_102385__F_102400 + N_102385__F_102401 + N_102385__F_102402 + N_102385__F_102403 + N_102385__F_102404 + N_102385__F_102487 + N_102385__F_102488 + "N_102383__F_102501" + mandatory + "N_102383__I_102504_i_F_102502" + mandatory + "N_102383__I_102504_i_F_102505" + alternative + N_102383__I_102504_i_F_102508 + N_102383__I_102504_i_F_102511 + N_102383__I_102504_i_F_102514 + N_102383__I_102504_i_F_102517 + N_102383__I_102504_i_F_102520 + N_102383__I_102504_i_F_102523 + N_102383__I_102504_i_F_102526 + N_102383__I_102504_i_F_102529 + N_102383__I_102504_i_F_102532 + N_102383__I_102504_i_F_102535 + N_102383__I_102504_i_F_102538 + N_102383__I_102504_i_F_102541 + N_102383__I_102504_i_F_102544 + N_102383__I_102504_i_F_102547 + N_102383__I_102504_i_F_102550 + N_102383__I_102504_i_F_102553 + N_102383__I_102504_i_F_102556 + N_102383__I_102504_i_F_102559 + N_102383__I_102504_i_F_102562 + N_102383__I_102504_i_F_102565 + "N_102383__I_102504_i_F_102568" + alternative + N_102383__I_102504_i_F_102571 + N_102383__I_102504_i_F_102574 + N_102383__I_102504_i_F_102577 + N_102383__I_102504_i_F_102580 + N_102383__I_102504_i_F_102583 + N_102383__I_102504_i_F_102586 + N_102383__I_102504_i_F_102589 + N_102383__I_102504_i_F_102592 + N_102383__I_102504_i_F_102595 + N_102383__I_102504_i_F_102598 + N_102383__I_102504_i_F_102601 + N_102383__I_102504_i_F_102604 + N_102383__I_102504_i_F_102607 + "N_102383__I_102504_i_F_102610" + alternative + N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102616 + "N_102383__I_102504_i_F_102619" + alternative + N_102383__I_102504_i_F_102622 + N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102628 + "N_102383__I_102504_i_F_102631" + alternative + N_102383__I_102504_i_F_102634 + N_102383__I_102504_i_F_102637 + "N_102383__I_102642_i_F_102640" + mandatory + "N_102383__I_102642_i_F_102643" + alternative + N_102383__I_102642_i_F_102646 + N_102383__I_102642_i_F_102649 + N_102383__I_102642_i_F_102652 + N_102383__I_102642_i_F_102655 + N_102383__I_102642_i_F_102658 + N_102383__I_102642_i_F_102661 + N_102383__I_102642_i_F_102664 + N_102383__I_102642_i_F_102667 + N_102383__I_102642_i_F_102670 + N_102383__I_102642_i_F_102673 + N_102383__I_102642_i_F_102676 + N_102383__I_102642_i_F_102679 + N_102383__I_102642_i_F_102682 + N_102383__I_102642_i_F_102685 + N_102383__I_102642_i_F_102688 + N_102383__I_102642_i_F_102691 + N_102383__I_102642_i_F_102694 + N_102383__I_102642_i_F_102697 + N_102383__I_102642_i_F_102700 + N_102383__I_102642_i_F_102703 + "N_102383__I_102642_i_F_102706" + alternative + N_102383__I_102642_i_F_102709 + N_102383__I_102642_i_F_102712 + N_102383__I_102642_i_F_102715 + N_102383__I_102642_i_F_102718 + N_102383__I_102642_i_F_102721 + N_102383__I_102642_i_F_102724 + N_102383__I_102642_i_F_102727 + N_102383__I_102642_i_F_102730 + N_102383__I_102642_i_F_102733 + N_102383__I_102642_i_F_102736 + N_102383__I_102642_i_F_102739 + N_102383__I_102642_i_F_102742 + N_102383__I_102642_i_F_102745 + "N_102383__I_102642_i_F_102748" + alternative + N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102754 + "N_102383__I_102642_i_F_102757" + alternative + N_102383__I_102642_i_F_102760 + N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102766 + "N_102383__I_102642_i_F_102769" + alternative + N_102383__I_102642_i_F_102772 + N_102383__I_102642_i_F_102775 + "N_102383__F_102778" + mandatory + "N_102383__F_102778_xor" {abstract} + alternative + N_102383__F_102779 + N_102383__F_102780 + N_102383__F_102781 + + optional + N_102383__F_102782 + N_102383__F_102783 + N_102383__F_102784 + N_102383__F_102785 + N_102383__F_102786 + N_102383__F_102787 + "N_102383__F_102788" + mandatory + "N_102383__I_103300_i_F_103298" + mandatory + "N_102383__I_103300_i_F_103346" + mandatory + "N_102383__I_103300_i_F_103364" + alternative + N_102383__I_103300_i_F_103367 + N_102383__I_103300_i_F_103370 + N_102383__I_103300_i_F_103373 + N_102383__I_103300_i_F_103376 + N_102383__I_103300_i_F_103379 + N_102383__I_103300_i_F_103382 + "N_102383__I_103300_i_F_103385" + mandatory + "N_102383__I_103300_i_F_103400" + alternative + N_102383__I_103300_i_F_103403 + N_102383__I_103300_i_F_103406 + "N_102383__I_103300_i_F_103409" + alternative + N_102383__I_103300_i_F_103412 + N_102383__I_103300_i_F_103415 + "N_102383__I_103300_i_F_103418" + alternative + N_102383__I_103300_i_F_103421 + N_102383__I_103300_i_F_103424 + + optional + "N_102383__I_103300_i_F_103388" + alternative + N_102383__I_103300_i_F_103391 + N_102383__I_103300_i_F_103394 + N_102383__I_103300_i_F_103397 + N_102383__I_103300_i_F_103427 + "N_102383__I_103300_i_F_103430" + alternative + N_102383__I_103300_i_F_103433 + N_102383__I_103300_i_F_103436 + "N_102383__I_103300_i_F_103439" + alternative + N_102383__I_103300_i_F_103442 + N_102383__I_103300_i_F_103445 + + optional + "N_102383__I_103300_i_F_103349" + alternative + N_102383__I_103300_i_F_103352 + N_102383__I_103300_i_F_103355 + N_102383__I_103300_i_F_103358 + N_102383__I_103300_i_F_103361 + "N_102383__I_103300_i_F_103448" + alternative + N_102383__I_103300_i_F_103451 + N_102383__I_103300_i_F_103454 + "N_102383__I_103300_i_F_103457" + mandatory + "N_102383__I_103300_i_F_103472" + alternative + N_102383__I_103300_i_F_103475 + N_102383__I_103300_i_F_103478 + N_102383__I_103300_i_F_103481 + N_102383__I_103300_i_F_103484 + "N_102383__I_103300_i_F_103487" + mandatory + "N_102383__I_103300_i_F_103502" + alternative + N_102383__I_103300_i_F_103505 + N_102383__I_103300_i_F_103508 + "N_102383__I_103300_i_F_103511" + alternative + N_102383__I_103300_i_F_103514 + N_102383__I_103300_i_F_103517 + "N_102383__I_103300_i_F_103520" + alternative + N_102383__I_103300_i_F_103523 + N_102383__I_103300_i_F_103526 + + optional + "N_102383__I_103300_i_F_103490" + alternative + N_102383__I_103300_i_F_103493 + N_102383__I_103300_i_F_103496 + N_102383__I_103300_i_F_103499 + N_102383__I_103300_i_F_103529 + "N_102383__I_103300_i_F_103532" + optional + N_102383__I_103300_i_F_103535 + "N_102383__I_103300_i_F_103538" + optional + N_102383__I_103300_i_F_103541 + + optional + "N_102383__I_103300_i_F_103460" + alternative + N_102383__I_103300_i_F_103463 + N_102383__I_103300_i_F_103466 + N_102383__I_103300_i_F_103469 + + optional + "N_102383__I_103300_i_F_103301" + alternative + N_102383__I_103300_i_F_103304 + N_102383__I_103300_i_F_103307 + N_102383__I_103300_i_F_103310 + N_102383__I_103300_i_F_103313 + N_102383__I_103300_i_F_103316 + N_102383__I_103300_i_F_103319 + N_102383__I_103300_i_F_103322 + N_102383__I_103300_i_F_103325 + N_102383__I_103300_i_F_103328 + N_102383__I_103300_i_F_103331 + N_102383__I_103300_i_F_103334 + N_102383__I_103300_i_F_103337 + N_102383__I_103300_i_F_103340 + N_102383__I_103300_i_F_103343 + "N_102383__I_103546_i_F_103544" + mandatory + "N_102383__I_103546_i_F_103592" + mandatory + "N_102383__I_103546_i_F_103610" + alternative + N_102383__I_103546_i_F_103613 + N_102383__I_103546_i_F_103616 + N_102383__I_103546_i_F_103619 + N_102383__I_103546_i_F_103622 + N_102383__I_103546_i_F_103625 + N_102383__I_103546_i_F_103628 + "N_102383__I_103546_i_F_103631" + mandatory + "N_102383__I_103546_i_F_103646" + alternative + N_102383__I_103546_i_F_103649 + N_102383__I_103546_i_F_103652 + "N_102383__I_103546_i_F_103655" + alternative + N_102383__I_103546_i_F_103658 + N_102383__I_103546_i_F_103661 + "N_102383__I_103546_i_F_103664" + alternative + N_102383__I_103546_i_F_103667 + N_102383__I_103546_i_F_103670 + + optional + "N_102383__I_103546_i_F_103634" + alternative + N_102383__I_103546_i_F_103637 + N_102383__I_103546_i_F_103640 + N_102383__I_103546_i_F_103643 + N_102383__I_103546_i_F_103673 + "N_102383__I_103546_i_F_103676" + alternative + N_102383__I_103546_i_F_103679 + N_102383__I_103546_i_F_103682 + "N_102383__I_103546_i_F_103685" + alternative + N_102383__I_103546_i_F_103688 + N_102383__I_103546_i_F_103691 + + optional + "N_102383__I_103546_i_F_103595" + alternative + N_102383__I_103546_i_F_103598 + N_102383__I_103546_i_F_103601 + N_102383__I_103546_i_F_103604 + N_102383__I_103546_i_F_103607 + "N_102383__I_103546_i_F_103694" + alternative + N_102383__I_103546_i_F_103697 + N_102383__I_103546_i_F_103700 + "N_102383__I_103546_i_F_103703" + mandatory + "N_102383__I_103546_i_F_103718" + alternative + N_102383__I_103546_i_F_103721 + N_102383__I_103546_i_F_103724 + N_102383__I_103546_i_F_103727 + N_102383__I_103546_i_F_103730 + "N_102383__I_103546_i_F_103733" + mandatory + "N_102383__I_103546_i_F_103748" + alternative + N_102383__I_103546_i_F_103751 + N_102383__I_103546_i_F_103754 + "N_102383__I_103546_i_F_103757" + alternative + N_102383__I_103546_i_F_103760 + N_102383__I_103546_i_F_103763 + "N_102383__I_103546_i_F_103766" + alternative + N_102383__I_103546_i_F_103769 + N_102383__I_103546_i_F_103772 + + optional + "N_102383__I_103546_i_F_103736" + alternative + N_102383__I_103546_i_F_103739 + N_102383__I_103546_i_F_103742 + N_102383__I_103546_i_F_103745 + N_102383__I_103546_i_F_103775 + "N_102383__I_103546_i_F_103778" + optional + N_102383__I_103546_i_F_103781 + "N_102383__I_103546_i_F_103784" + optional + N_102383__I_103546_i_F_103787 + + optional + "N_102383__I_103546_i_F_103706" + alternative + N_102383__I_103546_i_F_103709 + N_102383__I_103546_i_F_103712 + N_102383__I_103546_i_F_103715 + + optional + "N_102383__I_103546_i_F_103547" + alternative + N_102383__I_103546_i_F_103550 + N_102383__I_103546_i_F_103553 + N_102383__I_103546_i_F_103556 + N_102383__I_103546_i_F_103559 + N_102383__I_103546_i_F_103562 + N_102383__I_103546_i_F_103565 + N_102383__I_103546_i_F_103568 + N_102383__I_103546_i_F_103571 + N_102383__I_103546_i_F_103574 + N_102383__I_103546_i_F_103577 + N_102383__I_103546_i_F_103580 + N_102383__I_103546_i_F_103583 + N_102383__I_103546_i_F_103586 + N_102383__I_103546_i_F_103589 + + optional + "N_102383__F_102789" + alternative + N_102383__F_102790 + N_102383__F_102791 + N_102383__F_102792 + N_102383__F_102793 + N_102383__F_102794 + N_102383__F_102795 + N_102383__F_102796 + N_102383__F_102797 + N_102383__F_102798 + N_102383__F_102799 + N_102383__F_102800 + N_102383__F_102801 + N_102383__F_102802 + N_102383__F_102803 + N_102383__F_102804 + N_102383__F_102805 + "N_102383__I_102808_i_F_102806" + mandatory + "N_102383__I_102808_i_F_102809" + mandatory + "N_102383__I_102808_i_F_102821" + mandatory + N_102383__I_102808_i_F_102824 + "N_102383__I_102808_i_F_102827" + alternative + N_102383__I_102808_i_F_102830 + N_102383__I_102808_i_F_102833 + "N_102383__I_102808_i_F_102836" + alternative + N_102383__I_102808_i_F_102839 + N_102383__I_102808_i_F_102842 + "N_102383__I_102808_i_F_102845" + mandatory + "N_102383__I_102808_i_F_102845_xor" {abstract} + optional + "N_102383__I_102808_i_F_102848" + alternative + N_102383__I_102808_i_F_102851 + N_102383__I_102808_i_F_102854 + N_102383__I_102808_i_F_102857 + "N_102383__I_102808_i_F_102860" + alternative + N_102383__I_102808_i_F_102863 + N_102383__I_102808_i_F_102866 + "N_102383__I_102808_i_F_102869" + alternative + N_102383__I_102808_i_F_102872 + N_102383__I_102808_i_F_102875 + "N_102383__I_102808_i_F_102878" + alternative + N_102383__I_102808_i_F_102881 + N_102383__I_102808_i_F_102884 + + optional + "N_102383__I_102808_i_F_102812" + alternative + N_102383__I_102808_i_F_102815 + N_102383__I_102808_i_F_102818 + N_102383__I_102808_i_F_102887 + N_102383__I_102808_i_F_102890 + "N_102383__I_102808_i_F_102893" + mandatory + "N_102383__I_102808_i_F_102908" + mandatory + N_102383__I_102808_i_F_102911 + "N_102383__I_102808_i_F_102914" + mandatory + "N_102383__I_102808_i_F_102917" + alternative + N_102383__I_102808_i_F_102920 + N_102383__I_102808_i_F_102923 + N_102383__I_102808_i_F_102926 + N_102383__I_102808_i_F_102929 + "N_102383__I_102808_i_F_102932" + alternative + N_102383__I_102808_i_F_102935 + N_102383__I_102808_i_F_102938 + N_102383__I_102808_i_F_102941 + N_102383__I_102808_i_F_102944 + "N_102383__I_102808_i_F_102947" + alternative + N_102383__I_102808_i_F_102950 + N_102383__I_102808_i_F_102953 + N_102383__I_102808_i_F_102956 + "N_102383__I_102808_i_F_102959" + alternative + N_102383__I_102808_i_F_102962 + N_102383__I_102808_i_F_102965 + N_102383__I_102808_i_F_102968 + N_102383__I_102808_i_F_102971 + "N_102383__I_102808_i_F_102974" + alternative + N_102383__I_102808_i_F_102977 + N_102383__I_102808_i_F_102980 + N_102383__I_102808_i_F_102983 + "N_102383__I_102808_i_F_102986" + alternative + N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_102992 + N_102383__I_102808_i_F_102995 + "N_102383__I_102808_i_F_102998" + alternative + N_102383__I_102808_i_F_103001 + N_102383__I_102808_i_F_103004 + + optional + "N_102383__I_102808_i_F_102896" + alternative + N_102383__I_102808_i_F_102899 + N_102383__I_102808_i_F_102902 + N_102383__I_102808_i_F_102905 + "N_102383__I_102808_i_F_102806_xor" {abstract} + optional + "N_102383__I_102808_i_F_103007" + alternative + N_102383__I_102808_i_F_103010 + N_102383__I_102808_i_F_103013 + N_102383__I_102808_i_F_103016 + N_102383__I_102808_i_F_103019 + N_102383__I_102808_i_F_103022 + N_102383__I_102808_i_F_103025 + N_102383__I_102808_i_F_103028 + N_102383__I_102808_i_F_103031 + N_102383__I_102808_i_F_103034 + N_102383__I_102808_i_F_103037 + N_102383__I_102808_i_F_103040 + N_102383__I_102808_i_F_103043 + N_102383__I_102808_i_F_103046 + N_102383__I_102808_i_F_103049 + "N_102383__I_103054_i_F_103052" + mandatory + "N_102383__I_103054_i_F_103055" + mandatory + "N_102383__I_103054_i_F_103067" + mandatory + N_102383__I_103054_i_F_103070 + "N_102383__I_103054_i_F_103073" + alternative + N_102383__I_103054_i_F_103076 + N_102383__I_103054_i_F_103079 + "N_102383__I_103054_i_F_103082" + alternative + N_102383__I_103054_i_F_103085 + N_102383__I_103054_i_F_103088 + "N_102383__I_103054_i_F_103091" + mandatory + "N_102383__I_103054_i_F_103091_xor" {abstract} + optional + "N_102383__I_103054_i_F_103094" + alternative + N_102383__I_103054_i_F_103097 + N_102383__I_103054_i_F_103100 + N_102383__I_103054_i_F_103103 + "N_102383__I_103054_i_F_103106" + alternative + N_102383__I_103054_i_F_103109 + N_102383__I_103054_i_F_103112 + "N_102383__I_103054_i_F_103115" + alternative + N_102383__I_103054_i_F_103118 + N_102383__I_103054_i_F_103121 + "N_102383__I_103054_i_F_103124" + alternative + N_102383__I_103054_i_F_103127 + N_102383__I_103054_i_F_103130 + + optional + "N_102383__I_103054_i_F_103058" + alternative + N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103064 + N_102383__I_103054_i_F_103133 + N_102383__I_103054_i_F_103136 + "N_102383__I_103054_i_F_103139" + mandatory + "N_102383__I_103054_i_F_103154" + mandatory + N_102383__I_103054_i_F_103157 + "N_102383__I_103054_i_F_103160" + mandatory + "N_102383__I_103054_i_F_103163" + alternative + N_102383__I_103054_i_F_103166 + N_102383__I_103054_i_F_103169 + N_102383__I_103054_i_F_103172 + N_102383__I_103054_i_F_103175 + "N_102383__I_103054_i_F_103178" + alternative + N_102383__I_103054_i_F_103181 + N_102383__I_103054_i_F_103184 + N_102383__I_103054_i_F_103187 + N_102383__I_103054_i_F_103190 + "N_102383__I_103054_i_F_103193" + alternative + N_102383__I_103054_i_F_103196 + N_102383__I_103054_i_F_103199 + N_102383__I_103054_i_F_103202 + "N_102383__I_103054_i_F_103205" + alternative + N_102383__I_103054_i_F_103208 + N_102383__I_103054_i_F_103211 + N_102383__I_103054_i_F_103214 + N_102383__I_103054_i_F_103217 + "N_102383__I_103054_i_F_103220" + alternative + N_102383__I_103054_i_F_103223 + N_102383__I_103054_i_F_103226 + N_102383__I_103054_i_F_103229 + "N_102383__I_103054_i_F_103232" + alternative + N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103238 + N_102383__I_103054_i_F_103241 + "N_102383__I_103054_i_F_103244" + alternative + N_102383__I_103054_i_F_103247 + N_102383__I_103054_i_F_103250 + + optional + "N_102383__I_103054_i_F_103142" + alternative + N_102383__I_103054_i_F_103145 + N_102383__I_103054_i_F_103148 + N_102383__I_103054_i_F_103151 + "N_102383__I_103054_i_F_103052_xor" {abstract} + optional + "N_102383__I_103054_i_F_103253" + alternative + N_102383__I_103054_i_F_103256 + N_102383__I_103054_i_F_103259 + N_102383__I_103054_i_F_103262 + N_102383__I_103054_i_F_103265 + N_102383__I_103054_i_F_103268 + N_102383__I_103054_i_F_103271 + N_102383__I_103054_i_F_103274 + N_102383__I_103054_i_F_103277 + N_102383__I_103054_i_F_103280 + N_102383__I_103054_i_F_103283 + N_102383__I_103054_i_F_103286 + N_102383__I_103054_i_F_103289 + N_102383__I_103054_i_F_103292 + N_102383__I_103054_i_F_103295 + "N_102383__I_103792_i_F_103790" + mandatory + "N_102383__I_103792_i_F_103838" + mandatory + "N_102383__I_103792_i_F_103856" + alternative + N_102383__I_103792_i_F_103859 + N_102383__I_103792_i_F_103862 + N_102383__I_103792_i_F_103865 + N_102383__I_103792_i_F_103868 + N_102383__I_103792_i_F_103871 + N_102383__I_103792_i_F_103874 + "N_102383__I_103792_i_F_103877" + mandatory + "N_102383__I_103792_i_F_103892" + alternative + N_102383__I_103792_i_F_103895 + N_102383__I_103792_i_F_103898 + "N_102383__I_103792_i_F_103901" + alternative + N_102383__I_103792_i_F_103904 + N_102383__I_103792_i_F_103907 + "N_102383__I_103792_i_F_103910" + alternative + N_102383__I_103792_i_F_103913 + N_102383__I_103792_i_F_103916 + + optional + "N_102383__I_103792_i_F_103880" + alternative + N_102383__I_103792_i_F_103883 + N_102383__I_103792_i_F_103886 + N_102383__I_103792_i_F_103889 + N_102383__I_103792_i_F_103919 + "N_102383__I_103792_i_F_103922" + alternative + N_102383__I_103792_i_F_103925 + N_102383__I_103792_i_F_103928 + "N_102383__I_103792_i_F_103931" + alternative + N_102383__I_103792_i_F_103934 + N_102383__I_103792_i_F_103937 + + optional + "N_102383__I_103792_i_F_103841" + alternative + N_102383__I_103792_i_F_103844 + N_102383__I_103792_i_F_103847 + N_102383__I_103792_i_F_103850 + N_102383__I_103792_i_F_103853 + "N_102383__I_103792_i_F_103940" + alternative + N_102383__I_103792_i_F_103943 + N_102383__I_103792_i_F_103946 + "N_102383__I_103792_i_F_103949" + mandatory + "N_102383__I_103792_i_F_103964" + alternative + N_102383__I_103792_i_F_103967 + N_102383__I_103792_i_F_103970 + N_102383__I_103792_i_F_103973 + N_102383__I_103792_i_F_103976 + "N_102383__I_103792_i_F_103979" + mandatory + "N_102383__I_103792_i_F_103994" + alternative + N_102383__I_103792_i_F_103997 + N_102383__I_103792_i_F_104000 + "N_102383__I_103792_i_F_104003" + alternative + N_102383__I_103792_i_F_104006 + N_102383__I_103792_i_F_104009 + "N_102383__I_103792_i_F_104012" + alternative + N_102383__I_103792_i_F_104015 + N_102383__I_103792_i_F_104018 + + optional + "N_102383__I_103792_i_F_103982" + alternative + N_102383__I_103792_i_F_103985 + N_102383__I_103792_i_F_103988 + N_102383__I_103792_i_F_103991 + N_102383__I_103792_i_F_104021 + "N_102383__I_103792_i_F_104024" + optional + N_102383__I_103792_i_F_104027 + "N_102383__I_103792_i_F_104030" + optional + N_102383__I_103792_i_F_104033 + + optional + "N_102383__I_103792_i_F_103952" + alternative + N_102383__I_103792_i_F_103955 + N_102383__I_103792_i_F_103958 + N_102383__I_103792_i_F_103961 + + optional + "N_102383__I_103792_i_F_103793" + alternative + N_102383__I_103792_i_F_103796 + N_102383__I_103792_i_F_103799 + N_102383__I_103792_i_F_103802 + N_102383__I_103792_i_F_103805 + N_102383__I_103792_i_F_103808 + N_102383__I_103792_i_F_103811 + N_102383__I_103792_i_F_103814 + N_102383__I_103792_i_F_103817 + N_102383__I_103792_i_F_103820 + N_102383__I_103792_i_F_103823 + N_102383__I_103792_i_F_103826 + N_102383__I_103792_i_F_103829 + N_102383__I_103792_i_F_103832 + N_102383__I_103792_i_F_103835 + "N_102383__I_104038_i_F_104036" + mandatory + "N_102383__I_104038_i_F_104084" + mandatory + "N_102383__I_104038_i_F_104102" + alternative + N_102383__I_104038_i_F_104105 + N_102383__I_104038_i_F_104108 + N_102383__I_104038_i_F_104111 + N_102383__I_104038_i_F_104114 + N_102383__I_104038_i_F_104117 + N_102383__I_104038_i_F_104120 + "N_102383__I_104038_i_F_104123" + mandatory + "N_102383__I_104038_i_F_104138" + alternative + N_102383__I_104038_i_F_104141 + N_102383__I_104038_i_F_104144 + "N_102383__I_104038_i_F_104147" + alternative + N_102383__I_104038_i_F_104150 + N_102383__I_104038_i_F_104153 + "N_102383__I_104038_i_F_104156" + alternative + N_102383__I_104038_i_F_104159 + N_102383__I_104038_i_F_104162 + + optional + "N_102383__I_104038_i_F_104126" + alternative + N_102383__I_104038_i_F_104129 + N_102383__I_104038_i_F_104132 + N_102383__I_104038_i_F_104135 + N_102383__I_104038_i_F_104165 + "N_102383__I_104038_i_F_104168" + alternative + N_102383__I_104038_i_F_104171 + N_102383__I_104038_i_F_104174 + "N_102383__I_104038_i_F_104177" + alternative + N_102383__I_104038_i_F_104180 + N_102383__I_104038_i_F_104183 + + optional + "N_102383__I_104038_i_F_104087" + alternative + N_102383__I_104038_i_F_104090 + N_102383__I_104038_i_F_104093 + N_102383__I_104038_i_F_104096 + N_102383__I_104038_i_F_104099 + "N_102383__I_104038_i_F_104186" + alternative + N_102383__I_104038_i_F_104189 + N_102383__I_104038_i_F_104192 + "N_102383__I_104038_i_F_104195" + mandatory + "N_102383__I_104038_i_F_104210" + alternative + N_102383__I_104038_i_F_104213 + N_102383__I_104038_i_F_104216 + N_102383__I_104038_i_F_104219 + N_102383__I_104038_i_F_104222 + "N_102383__I_104038_i_F_104225" + mandatory + "N_102383__I_104038_i_F_104240" + alternative + N_102383__I_104038_i_F_104243 + N_102383__I_104038_i_F_104246 + "N_102383__I_104038_i_F_104249" + alternative + N_102383__I_104038_i_F_104252 + N_102383__I_104038_i_F_104255 + "N_102383__I_104038_i_F_104258" + alternative + N_102383__I_104038_i_F_104261 + N_102383__I_104038_i_F_104264 + + optional + "N_102383__I_104038_i_F_104228" + alternative + N_102383__I_104038_i_F_104231 + N_102383__I_104038_i_F_104234 + N_102383__I_104038_i_F_104237 + N_102383__I_104038_i_F_104267 + "N_102383__I_104038_i_F_104270" + optional + N_102383__I_104038_i_F_104273 + "N_102383__I_104038_i_F_104276" + optional + N_102383__I_104038_i_F_104279 + + optional + "N_102383__I_104038_i_F_104198" + alternative + N_102383__I_104038_i_F_104201 + N_102383__I_104038_i_F_104204 + N_102383__I_104038_i_F_104207 + + optional + "N_102383__I_104038_i_F_104039" + alternative + N_102383__I_104038_i_F_104042 + N_102383__I_104038_i_F_104045 + N_102383__I_104038_i_F_104048 + N_102383__I_104038_i_F_104051 + N_102383__I_104038_i_F_104054 + N_102383__I_104038_i_F_104057 + N_102383__I_104038_i_F_104060 + N_102383__I_104038_i_F_104063 + N_102383__I_104038_i_F_104066 + N_102383__I_104038_i_F_104069 + N_102383__I_104038_i_F_104072 + N_102383__I_104038_i_F_104075 + N_102383__I_104038_i_F_104078 + N_102383__I_104038_i_F_104081 + N_104282__F_104283 + + optional + "N_104284__F_104285" + mandatory + "N_104284__F_104286" + alternative + N_104284__F_104287 + N_104284__F_104288 + "N_104284__F_104289" + mandatory + "N_104284__F_104290" + mandatory + "N_104284__F_104290_xor" {abstract} + alternative + "N_104284__F_104291" + optional + "N_104284__F_104292" + optional + N_104284__F_104293 + "N_104284__F_104294" + alternative + N_104284__F_104295 + N_104284__F_104296 + "N_104284__F_104308" + alternative + N_104284__F_104309 + N_104284__F_104310 + + optional + "N_104284__F_104297" + alternative + "N_104284__F_104298" + alternative + "N_104284__F_104299" + alternative + N_104284__F_104300 + N_104284__F_104301 + N_104284__F_104302 + "N_104284__F_104303" + alternative + "N_104284__F_104304" + alternative + N_104284__F_104305 + N_104284__F_104306 + N_104284__F_104307 + + optional + "N_104284__F_104311" + mandatory + "N_104284__F_104312" + alternative + N_104284__F_104313 + N_104284__F_104314 + "N_104284__F_104326" + alternative + N_104284__F_104327 + N_104284__F_104328 + + optional + "N_104284__F_104315" + alternative + "N_104284__F_104316" + alternative + "N_104284__F_104317" + alternative + N_104284__F_104318 + N_104284__F_104319 + N_104284__F_104320 + "N_104284__F_104321" + alternative + "N_104284__F_104322" + alternative + N_104284__F_104323 + N_104284__F_104324 + N_104284__F_104325 + N_104284__F_104329 + + optional + "N_104284__F_104330" + or + N_104284__F_104331 + N_104284__F_104332 + N_104284__F_104333 + "N_104334__F_104335" + mandatory + "N_104334__F_104336" + alternative + N_104334__F_104337 + N_104334__F_104338 + N_104334__F_104339 + N_104334__F_104340 + N_104334__F_104341 + "N_104334__F_104342" + mandatory + "N_104334__F_104343" + alternative + N_104334__F_104344 + N_104334__F_104345 + "N_104334__F_104346" + alternative + N_104334__F_104347 + N_104334__F_104348 + "N_104334__F_104349" + alternative + N_104334__F_104350 + N_104334__F_104351 + "N_104334__F_104352" + alternative + N_104334__F_104353 + N_104334__F_104354 + N_100000__F_104355 + "N_100000__F_104356" + mandatory + "N_104357__F_104358" + mandatory + "N_104357__F_104359" + alternative + N_104357__F_104360 + N_104357__F_104361 + N_104357__F_104362 + N_104357__F_104363 + N_104357__F_104364 + N_104357__F_104365 + N_104357__F_104366 + N_104357__F_104367 + N_104357__F_104368 + N_104357__F_104369 + N_104357__F_104370 + N_104357__F_104371 + N_104357__F_104372 + N_104357__F_104373 + N_104357__F_104374 + N_104357__F_104375 + N_104357__F_104376 + N_104357__F_104377 + N_104357__F_104378 + N_104357__F_104379 + N_104357__F_104380 + N_104357__F_104381 + N_104357__F_104382 + "N_104357__F_104408" + mandatory + "N_104357__F_104409" + mandatory + "N_104357__F_104410" + alternative + N_104357__F_104411 + N_104357__F_104412 + N_104357__F_104413 + N_104357__F_104414 + N_104357__F_104415 + N_104357__F_104416 + N_104357__F_104417 + N_104357__F_104418 + N_104357__F_104419 + N_104357__F_104420 + N_104357__F_104421 + N_104357__F_104422 + N_104357__F_104423 + N_104357__F_104424 + N_104357__F_104425 + N_104357__F_104426 + "N_104357__F_104427" + alternative + N_104357__F_104428 + N_104357__F_104429 + N_104357__F_104430 + N_104357__F_104431 + N_104357__F_104432 + "N_104357__F_104433" + alternative + N_104357__F_104434 + N_104357__F_104435 + N_104357__F_104436 + N_104357__F_104437 + N_104357__F_104438 + N_104357__F_104439 + N_104357__F_104440 + "N_104357__F_104441" + alternative + N_104357__F_104442 + N_104357__F_104443 + N_104357__F_104444 + N_104357__F_104445 + "N_104357__F_104446" + alternative + N_104357__F_104447 + N_104357__F_104448 + N_104357__F_104449 + "N_104357__F_104450" + alternative + N_104357__F_104451 + N_104357__F_104452 + N_104357__F_104453 + N_104357__F_104454 + "N_104357__F_104455" + mandatory + "N_104357__F_104456" + alternative + N_104357__F_104457 + N_104357__F_104458 + "N_104357__F_104459" + mandatory + "N_104357__F_104460" + alternative + N_104357__F_104461 + N_104357__F_104462 + "N_104357__F_104463" + mandatory + "N_104357__F_104463_xor" {abstract} + alternative + N_104357__F_104464 + N_104357__F_104465 + N_104357__F_104466 + + optional + "N_104357__F_104467" + alternative + N_104357__F_104468 + N_104357__F_104469 + "N_104357__F_104470" + mandatory + "N_104357__F_104471" + alternative + N_104357__F_104472 + N_104357__F_104473 + N_104357__F_104474 + N_104357__F_104475 + "N_104357__F_104476" + mandatory + "N_104357__F_104477" + alternative + N_104357__F_104478 + "N_104357__F_104479" + optional + N_104357__F_104480 + N_104357__F_104481 + "N_104357__F_104482" + mandatory + "N_104357__F_104483" + alternative + N_104357__F_104484 + N_104357__F_104485 + "N_104357__F_104486" + alternative + N_104357__F_104487 + N_104357__F_104488 + "N_104357__F_104489" + alternative + N_104357__F_104490 + N_104357__F_104491 + "N_104357__F_104492" + mandatory + "N_104357__F_104493" + alternative + N_104357__F_104494 + N_104357__F_104495 + "N_104357__F_104496" + mandatory + "N_104357__F_104496_xor" {abstract} + alternative + N_104357__F_104500 + "N_104357__F_104501" + optional + N_104357__F_104502 + N_104357__F_104503 + "N_104357__F_104510" + alternative + N_104357__F_104511 + N_104357__F_104512 + N_104357__F_104513 + + optional + "N_104357__F_104497" + alternative + N_104357__F_104498 + N_104357__F_104499 + "N_104357__F_104504" + optional + N_104357__F_104505 + "N_104357__F_104506" + alternative + N_104357__F_104507 + N_104357__F_104508 + N_104357__F_104509 + "N_104357__F_104514" + mandatory + "N_104357__F_104515" + alternative + N_104357__F_104516 + N_104357__F_104517 + "N_104357__F_104518" + alternative + N_104357__F_104519 + N_104357__F_104520 + + optional + "N_104357__F_104521" + optional + N_104357__F_104522 + N_104357__F_104523 + + optional + "N_104357__F_104383" + optional + "N_104357__F_104384" + optional + N_104357__F_104385 + "N_104357__F_104386" + alternative + N_104357__F_104387 + N_104357__F_104388 + "N_104357__F_104389" + alternative + N_104357__F_104390 + N_104357__F_104391 + "N_104357__F_104392" + alternative + N_104357__F_104393 + N_104357__F_104394 + N_104357__F_104395 + N_104357__F_104396 + "N_104357__F_104397" + mandatory + "N_104357__F_104398" + alternative + N_104357__F_104399 + N_104357__F_104400 + "N_104357__F_104401" + alternative + N_104357__F_104402 + N_104357__F_104403 + N_104357__F_104404 + N_104357__F_104405 + N_104357__F_104406 + N_104357__F_104407 + "N_104524__F_104525" + optional + N_104524__F_104526 + N_104524__F_104527 + N_104524__F_104528 + "N_104524__F_104529" + optional + N_104524__F_104530 + N_104524__F_104531 + N_104524__F_104532 + "N_104524__F_104533" + alternative + N_104524__F_104534 + N_104524__F_104535 + "N_104536__F_104537" + mandatory + "N_104536__F_104537_or" {abstract} + or + "N_104536__I_104551_i_F_104549" + mandatory + "N_104536__I_104551_i_F_104552" + alternative + N_104536__I_104551_i_F_104555 + N_104536__I_104551_i_F_104558 + + optional + N_104536__I_104551_i_F_104561 + "N_104536__I_104566_i_F_104564" + mandatory + "N_104536__I_104566_i_F_104567" + alternative + N_104536__I_104566_i_F_104570 + N_104536__I_104566_i_F_104573 + + optional + N_104536__I_104566_i_F_104576 + "N_104536__I_104581_i_F_104579" + mandatory + "N_104536__I_104581_i_F_104582" + alternative + N_104536__I_104581_i_F_104585 + N_104536__I_104581_i_F_104588 + + optional + N_104536__I_104581_i_F_104591 + "N_104536__I_104596_i_F_104594" + mandatory + "N_104536__I_104596_i_F_104597" + alternative + N_104536__I_104596_i_F_104600 + N_104536__I_104596_i_F_104603 + + optional + N_104536__I_104596_i_F_104606 + "N_104536__I_104611_i_F_104609" + mandatory + "N_104536__I_104611_i_F_104612" + alternative + N_104536__I_104611_i_F_104615 + N_104536__I_104611_i_F_104618 + + optional + N_104536__I_104611_i_F_104621 + "N_104536__I_104626_i_F_104624" + mandatory + "N_104536__I_104626_i_F_104627" + alternative + N_104536__I_104626_i_F_104630 + N_104536__I_104626_i_F_104633 + + optional + N_104536__I_104626_i_F_104636 + + optional + "N_104536__F_104538" + alternative + N_104536__F_104539 + N_104536__F_104540 + N_104536__F_104541 + N_104536__F_104542 + N_104536__F_104543 + N_104536__F_104544 + N_104536__F_104545 + "N_104536__F_104546" + alternative + N_104536__F_104547 + N_104536__F_104548 + "N_104536__F_104639" + alternative + N_104536__F_104640 + N_104536__F_104641 + "N_104642__F_104643" + mandatory + "N_104642__F_104644" + alternative + N_104642__F_104645 + N_104642__F_104646 + + optional + N_104642__F_104647 + "N_100000__F_104648" + mandatory + "N_104649__F_104650" + mandatory + "N_104649__F_104656" + mandatory + "N_104649__F_104657" + alternative + N_104649__F_104658 + N_104649__F_104659 + "N_104649__F_104660" + alternative + N_104649__F_104661 + N_104649__F_104662 + N_104649__F_104663 + N_104649__F_104664 + "N_104649__F_104665" + alternative + N_104649__F_104666 + N_104649__F_104667 + "N_104649__F_104668" + alternative + N_104649__F_104669 + N_104649__F_104670 + N_104649__F_104671 + N_104649__F_104672 + "N_104649__F_104673" + alternative + N_104649__F_104674 + N_104649__F_104675 + N_104649__F_104676 + N_104649__F_104677 + N_104649__F_104678 + N_104649__F_104679 + "N_104649__F_104680" + alternative + N_104649__F_104681 + N_104649__F_104682 + N_104649__F_104683 + N_104649__F_104684 + N_104649__F_104685 + N_104649__F_104686 + "N_104687__F_104688" + alternative + N_104687__F_104689 + N_104687__F_104690 + "N_104687__F_104691" + alternative + N_104687__F_104692 + N_104687__F_104693 + "N_104687__F_104694" + alternative + N_104687__F_104695 + N_104687__F_104696 + N_104687__F_104697 + N_104687__F_104698 + N_104687__F_104699 + "N_104700__F_104701" + alternative + "N_104700__F_104702" + alternative + N_104700__F_104703 + N_104700__F_104704 + N_104700__F_104705 + N_104700__F_104706 + N_104700__F_104707 + N_104700__F_104708 + N_104700__F_104709 + N_104700__F_104710 + N_104700__F_104711 + N_104700__F_104712 + N_104700__F_104713 + N_104700__F_104714 + N_104700__F_104715 + N_104700__F_104716 + N_104700__F_104717 + N_104700__F_104718 + N_104700__F_104719 + N_104700__F_104720 + N_104700__F_104721 + N_104700__F_104722 + N_104700__F_104723 + N_104700__F_104724 + "N_104700__F_104725" + optional + N_104700__F_104726 + "N_104649__F_104839" + alternative + N_104649__F_104840 + N_104649__F_104841 + N_104649__F_104842 + + optional + "N_104649__F_104651" + alternative + N_104649__F_104652 + N_104649__F_104653 + N_104649__F_104654 + N_104649__F_104655 + "N_104649__F_104727" + optional + "N_104649__F_104728" + alternative + N_104649__F_104729 + N_104649__F_104730 + "N_104649__F_104731" + optional + "N_104649__F_104732" + alternative + N_104649__F_104733 + N_104649__F_104734 + "N_104649__F_104735" + optional + "N_104649__F_104736" + alternative + N_104649__F_104737 + N_104649__F_104738 + N_104649__F_104739 + "N_104649__F_104740" + alternative + N_104649__F_104741 + N_104649__F_104742 + "N_104649__F_104743" + alternative + N_104649__F_104744 + N_104649__F_104745 + "N_104649__F_104746" + alternative + N_104649__F_104747 + N_104649__F_104748 + N_104649__F_104749 + "N_104649__F_104750" + optional + N_104649__F_104751 + N_104649__F_104752 + N_104649__F_104753 + N_104649__F_104754 + N_104649__F_104755 + N_104649__F_104756 + "N_104649__F_104757" + alternative + N_104649__F_104758 + N_104649__F_104759 + "N_104649__F_104760" + or + "N_104649__F_104761" + mandatory + "N_104649__F_104762" + mandatory + "N_104649__F_104763" + alternative + N_104649__F_104764 + N_104649__F_104765 + "N_104649__F_104766" + alternative + N_104649__F_104767 + N_104649__F_104768 + "N_104649__F_104769" + alternative + N_104649__F_104770 + N_104649__F_104771 + "N_104649__F_104772" + mandatory + N_104649__F_104773 + + optional + N_104649__F_104774 + "N_104649__F_104775" + mandatory + "N_104649__F_104776" + mandatory + "N_104649__F_104777" + alternative + N_104649__F_104778 + N_104649__F_104779 + "N_104649__F_104780" + alternative + N_104649__F_104781 + N_104649__F_104782 + "N_104649__F_104783" + alternative + N_104649__F_104784 + N_104649__F_104785 + "N_104649__F_104786" + mandatory + N_104649__F_104787 + + optional + N_104649__F_104788 + "N_104649__F_104789" + mandatory + "N_104649__F_104790" + mandatory + "N_104649__F_104791" + alternative + N_104649__F_104792 + N_104649__F_104793 + "N_104649__F_104794" + alternative + N_104649__F_104795 + N_104649__F_104796 + "N_104649__F_104797" + alternative + N_104649__F_104798 + N_104649__F_104799 + "N_104649__F_104800" + mandatory + N_104649__F_104801 + "N_104649__F_104802" + mandatory + "N_104649__F_104803" + mandatory + "N_104649__F_104804" + alternative + N_104649__F_104805 + N_104649__F_104806 + "N_104649__F_104807" + alternative + N_104649__F_104808 + N_104649__F_104809 + "N_104649__F_104810" + mandatory + N_104649__F_104811 + "N_104649__F_104812" + mandatory + N_104649__F_104813 + "N_104649__F_104814" + optional + "N_104649__I_104817_i_F_104815" + mandatory + "N_104649__I_104817_i_F_104818" + alternative + N_104649__I_104817_i_F_104821 + N_104649__I_104817_i_F_104824 + "N_104649__I_104817_i_F_104827" + mandatory + "N_104649__I_104817_i_F_104830" + alternative + N_104649__I_104817_i_F_104833 + N_104649__I_104817_i_F_104836 + "N_104843__F_104844" + optional + "N_104843__F_104845" + alternative + N_104843__F_104846 + N_104843__F_104847 + N_104843__F_104848 + "N_104849__F_104850" + alternative + N_104849__F_104851 + N_104849__F_104852 + N_104849__F_104853 + + optional + "N_100000__F_104854" + optional + "N_100000__F_104855" + optional + N_100000__F_104856 + N_100000__F_104857 + N_100000__F_104858 + +constraints + "N_100002__F_100005" => N_100002__F_100015 + "N_100002__F_100005" => N_100002__F_100107 + "N_100002__F_100005" => "N_100002__F_100013" + N_100002__F_100007 => N_100002__F_100015 + N_100002__F_100007 => N_100002__F_100108 + N_100002__F_100007 => "N_100002__F_100013" + N_100002__F_100008 => N_100002__F_100016 + N_100002__F_100008 => N_100002__F_100107 + N_100002__F_100008 => "N_100002__F_100013" + N_100002__F_100009 => N_100002__F_100016 + N_100002__F_100009 => N_100002__F_100108 + N_100002__F_100009 => "N_100002__F_100013" + N_100002__F_100010 => N_100002__F_100109 + N_100002__F_100011 => "N_100002__F_100017" + !("N_100002__F_100013" & "N_100300__F_100332") + !("N_100002__F_100013" & "N_100130__F_100297") + N_100002__F_100105 => "N_100300__F_100332" + !(N_100002__F_100105 & "N_100130__F_100132") + N_100002__F_100111 => "N_104536__F_104538" + N_100002__F_100112 => "N_104536__F_104546" + "N_100300__F_100303" => N_100300__F_100341 + N_100300__F_100321 => N_100000__F_101763 + N_100300__F_100321 => N_100300__F_100342 + N_100300__F_100321 => N_104282__F_104283 + !(N_100300__F_100321 & "N_102383__F_102384") + N_100300__F_100321 => N_100000__F_101282 + !(N_100300__F_100321 & N_100000__F_101275) + !(N_100300__F_100321 & N_100000__F_101276) + !(N_100300__F_100321 & N_100000__F_101277) + !(N_100300__F_100321 & N_100000__F_101278) + !(N_100300__F_100321 & N_100000__F_101279) + !(N_100300__F_100321 & N_100000__F_101280) + !(N_100300__F_100321 & N_100000__F_101281) + N_100300__F_100321 => N_100300__F_100339 + N_100300__F_100341 => "N_102383__F_102384" + N_100300__F_100342 => N_104282__F_104283 + N_100353__F_100357 => N_100353__F_100359 + N_100353__F_100357 => N_100353__F_100360 + N_100353__F_100357 => N_100353__F_100361 + N_100353__F_100357 => N_100353__F_100368 + N_100353__F_100357 => N_100353__F_100363 + N_100353__F_100357 => N_100353__F_100364 + N_100353__F_100357 => "N_100353__F_100370" + N_100353__F_100357 => "N_100353__F_100380" + N_100353__F_100357 => "N_100353__F_100390" + N_100353__F_100357 => "N_100353__F_100447" + N_100353__F_100357 => "N_100353__F_100454" + N_100353__F_100357 => "N_100353__F_100456" + N_100353__F_100359 => "N_101764__F_101765" + N_100353__F_100360 => "N_101764__F_101765" + N_100353__F_100361 => "N_101764__F_101765" + "N_100353__F_100370" => "N_100618__F_100674" + "N_100353__F_100380" => "N_100618__F_100732" + "N_100353__F_100386" => "N_100618__F_100648" + "N_100353__F_100390" => "N_100618__F_100759" + "N_100353__F_100405" => "N_101906__F_101907" + "N_100353__F_100421" => "N_100618__F_100790" + N_100353__F_100433 => "N_100469__I_100554_i_F_100552" + N_100353__F_100434 => "N_100469__I_100542_i_F_100540" + "N_100353__F_100447" => "N_102043__F_102283" + "N_100353__F_100454" => "N_102043__F_102333" + "N_100353__F_100456" => "N_102043__F_102356" + N_100353__F_100461 => "N_102043__F_102194" + N_102026__F_102028 => N_102026__F_102031 + N_100002__F_100006 => N_100002__F_100111 + "N_100130__F_100138" => "N_100000__I_100976_i_F_100974" + "N_100130__F_100138" => "N_100000__I_101174_i_F_101172" + "N_100130__F_100153" => N_100353__F_100361 + N_100130__F_100169 => N_100353__F_100429 + N_100130__F_100169 => N_100353__F_100432 + N_100130__F_100169 => N_100353__F_100414 + N_100130__F_100169 => N_100353__F_100431 + N_100130__F_100169 => N_100353__F_100409 + "N_100130__F_100225" => N_100353__F_100431 + "N_100130__F_100225" => N_100353__F_100414 + "N_100130__F_100225" => "N_100130__F_100218" + N_100130__F_100266 => N_100353__F_100430 + "N_100130__F_100283" => N_100353__F_100360 + N_100130__F_100290 => N_100353__F_100461 + N_100353__F_100367 => "N_101932__F_101933" + N_100353__F_100368 => "N_101932__F_101933" + N_100353__F_100369 => "N_101932__F_101933" + N_100353__F_100371 => N_100618__F_100702 + N_100353__F_100372 => N_100618__F_100697 + N_100353__F_100373 => N_100618__F_100696 + N_100353__F_100374 => N_100618__F_100699 + N_100353__F_100375 => N_100618__F_100700 + N_100353__F_100376 => N_100618__F_100701 + N_100353__F_100377 => N_100618__F_100704 + N_100353__F_100378 => N_100618__F_100703 + N_100353__F_100379 => N_100618__F_100698 + N_100353__F_100381 => N_100618__F_100757 + N_100353__F_100382 => N_100618__F_100755 + N_100353__F_100383 => N_100618__F_100758 + N_100353__F_100384 => N_100618__F_100756 + N_100353__F_100385 => N_100618__F_100754 + N_100353__F_100422 => N_100618__F_100812 + N_100353__F_100423 => N_100618__F_100813 + N_100353__F_100424 => N_100618__F_100814 + N_100353__F_100425 => N_100618__F_100815 + N_100353__F_100426 => N_100618__F_100816 + N_100353__F_100427 => N_100618__F_100817 + N_100353__F_100429 => N_100618__F_100818 + N_100353__F_100430 => N_100618__F_100819 + N_100353__F_100448 => N_102043__F_102305 + N_100353__F_100449 => N_102043__F_102307 + N_100353__F_100450 => N_102043__F_102306 + N_100353__F_100451 => N_102043__F_102309 + N_100353__F_100452 => N_102043__F_102310 + N_100353__F_100453 => N_102043__F_102308 + N_100353__F_100457 => N_102043__F_102379 + N_100353__F_100458 => N_102043__F_102380 + N_100353__F_100459 => N_102043__F_102381 + N_100353__F_100460 => N_102043__F_102378 + !("N_101906__F_101907" & N_104687__F_104698) + !(N_102026__F_102031 & N_102026__F_102030) + "N_100002__F_100020" => "N_100002__F_100034" + "N_100002__F_100020" => "N_100002__F_100036" + N_100130__F_100147 => N_102026__F_102028 + N_100130__F_100284 => "N_100130__F_100225" + N_100300__F_100312 => "N_100300__F_100330" + N_100300__F_100313 => N_100300__F_100324 + N_100300__F_100313 => "N_100300__F_100325" + "N_100300__F_100314" => N_100300__F_100324 + N_100300__F_100318 => N_100300__F_100324 + N_100300__F_100319 => N_100300__F_100324 + N_100300__F_100319 => "N_100300__F_100325" + N_100300__F_100326 => N_100300__F_100341 + N_100300__F_100326 => N_100000__F_104355 + N_100300__F_100326 => N_100000__F_102003 + N_100000__F_101275 => N_100000__I_101285_i_F_101337 + !(N_100000__F_101275 & "N_100000__I_101405_i_F_101403") + !(N_100000__F_101275 & "N_100000__I_101525_i_F_101523") + !(N_100000__F_101275 & "N_100000__I_101645_i_F_101643") + N_100000__F_101275 => N_100000__I_101285_i_F_101394 + N_100000__F_101276 => N_100000__I_101285_i_F_101340 + !(N_100000__F_101276 & "N_100000__I_101405_i_F_101403") + !(N_100000__F_101276 & "N_100000__I_101525_i_F_101523") + !(N_100000__F_101276 & "N_100000__I_101645_i_F_101643") + N_100000__F_101276 => N_100000__I_101285_i_F_101394 + N_100000__F_101277 => N_100000__I_101285_i_F_101337 + N_100000__F_101277 => N_100000__I_101405_i_F_101469 + !(N_100000__F_101277 & "N_100000__I_101525_i_F_101523") + !(N_100000__F_101277 & "N_100000__I_101645_i_F_101643") + N_100000__F_101277 => N_100000__I_101285_i_F_101394 + N_100000__F_101277 => N_100000__I_101405_i_F_101514 + N_100000__F_101278 => N_100000__I_101285_i_F_101337 + N_100000__F_101278 => N_100000__I_101405_i_F_101469 + N_100000__F_101278 => N_100000__I_101525_i_F_101586 + !(N_100000__F_101278 & "N_100000__I_101645_i_F_101643") + N_100000__F_101278 => N_100000__I_101285_i_F_101394 + N_100000__F_101278 => N_100000__I_101405_i_F_101517 + N_100000__F_101278 => N_100000__I_101525_i_F_101637 + N_100000__F_101279 => N_100000__I_101285_i_F_101340 + N_100000__F_101279 => N_100000__I_101405_i_F_101469 + N_100000__F_101279 => N_100000__I_101525_i_F_101586 + !(N_100000__F_101279 & "N_100000__I_101645_i_F_101643") + N_100000__F_101279 => N_100000__I_101285_i_F_101394 + N_100000__F_101279 => N_100000__I_101405_i_F_101517 + N_100000__F_101279 => N_100000__I_101525_i_F_101637 + N_100000__F_101280 => N_100000__I_101285_i_F_101337 + N_100000__F_101280 => N_100000__I_101405_i_F_101469 + N_100000__F_101280 => N_100000__I_101525_i_F_101592 + !(N_100000__F_101280 & "N_100000__I_101645_i_F_101643") + N_100000__F_101280 => N_100000__I_101285_i_F_101394 + N_100000__F_101280 => N_100000__I_101405_i_F_101517 + N_100000__F_101280 => N_100000__I_101525_i_F_101637 + N_100000__F_101281 => N_100000__I_101285_i_F_101340 + N_100000__F_101281 => N_100000__I_101405_i_F_101469 + N_100000__F_101281 => N_100000__I_101525_i_F_101592 + !(N_100000__F_101281 & "N_100000__I_101645_i_F_101643") + N_100000__F_101281 => N_100000__I_101285_i_F_101394 + N_100000__F_101281 => N_100000__I_101405_i_F_101517 + N_100000__F_101281 => N_100000__I_101525_i_F_101637 + N_100000__F_101282 => N_100000__I_101285_i_F_101340 + N_100000__F_101282 => N_100000__I_101645_i_F_101718 + !(N_100000__F_101282 & "N_100000__I_101405_i_F_101403") + !(N_100000__F_101282 & "N_100000__I_101525_i_F_101523") + N_100000__F_101282 => N_100000__I_101645_i_F_101751 + N_100000__F_101282 => N_100000__I_101285_i_F_101400 + "N_100000__I_101285_i_F_101283" => "N_100000__I_101285_i_F_101334" + "N_100000__I_101405_i_F_101403" => N_100000__I_101405_i_F_101469 + !("N_100000__I_101525_i_F_101523" & "N_100000__I_101525_i_F_101574") + !("N_100000__I_101525_i_F_101523" & N_100000__I_101525_i_F_101589) + N_104357__F_104360 => N_104357__F_104411 + N_104357__F_104360 => N_104357__F_104428 + N_104357__F_104360 => N_104357__F_104435 + N_104357__F_104360 => N_104357__F_104442 + N_104357__F_104360 => N_104357__F_104447 + N_104357__F_104360 => N_104357__F_104451 + !(N_104357__F_104360 & N_104357__F_104406) + N_104357__F_104361 => N_104357__F_104411 + N_104357__F_104361 => N_104357__F_104428 + N_104357__F_104361 => N_104357__F_104435 + N_104357__F_104361 => N_104357__F_104442 + N_104357__F_104361 => N_104357__F_104447 + N_104357__F_104361 => N_104357__F_104452 + !(N_104357__F_104361 & N_104357__F_104406) + N_104357__F_104362 => N_104357__F_104411 + N_104357__F_104362 => N_104357__F_104429 + N_104357__F_104362 => N_104357__F_104435 + N_104357__F_104362 => N_104357__F_104442 + N_104357__F_104362 => N_104357__F_104447 + N_104357__F_104362 => N_104357__F_104451 + !(N_104357__F_104362 & N_104357__F_104406) + N_104357__F_104363 => N_104357__F_104414 + N_104357__F_104363 => N_104357__F_104428 + N_104357__F_104363 => N_104357__F_104435 + N_104357__F_104363 => N_104357__F_104442 + N_104357__F_104363 => N_104357__F_104447 + N_104357__F_104363 => N_104357__F_104452 + !(N_104357__F_104363 & N_104357__F_104406) + N_104357__F_104364 => N_104357__F_104414 + N_104357__F_104364 => N_104357__F_104429 + N_104357__F_104364 => N_104357__F_104435 + N_104357__F_104364 => N_104357__F_104442 + N_104357__F_104364 => N_104357__F_104447 + N_104357__F_104364 => N_104357__F_104452 + !(N_104357__F_104364 & N_104357__F_104406) + N_104357__F_104365 => N_104357__F_104414 + N_104357__F_104365 => N_104357__F_104429 + N_104357__F_104365 => N_104357__F_104435 + N_104357__F_104365 => N_104357__F_104442 + N_104357__F_104365 => N_104357__F_104447 + N_104357__F_104365 => N_104357__F_104451 + !(N_104357__F_104365 & N_104357__F_104406) + N_104357__F_104366 => N_104357__F_104415 + N_104357__F_104366 => N_104357__F_104428 + N_104357__F_104366 => N_104357__F_104438 + N_104357__F_104366 => N_104357__F_104442 + N_104357__F_104366 => N_104357__F_104447 + N_104357__F_104366 => N_104357__F_104452 + N_104357__F_104367 => N_104357__F_104415 + N_104357__F_104367 => N_104357__F_104429 + N_104357__F_104367 => N_104357__F_104435 + N_104357__F_104367 => N_104357__F_104442 + N_104357__F_104367 => N_104357__F_104447 + N_104357__F_104367 => N_104357__F_104452 + !(N_104357__F_104367 & N_104357__F_104406) + N_104357__F_104368 => N_104357__F_104415 + N_104357__F_104368 => N_104357__F_104430 + N_104357__F_104368 => N_104357__F_104438 + N_104357__F_104368 => N_104357__F_104442 + N_104357__F_104368 => N_104357__F_104447 + N_104357__F_104368 => N_104357__F_104451 + N_104357__F_104369 => N_104357__F_104415 + N_104357__F_104369 => N_104357__F_104430 + N_104357__F_104369 => N_104357__F_104438 + N_104357__F_104369 => N_104357__F_104442 + N_104357__F_104369 => N_104357__F_104447 + N_104357__F_104369 => N_104357__F_104452 + N_104357__F_104370 => N_104357__F_104415 + N_104357__F_104370 => N_104357__F_104430 + N_104357__F_104370 => N_104357__F_104435 + N_104357__F_104370 => N_104357__F_104442 + N_104357__F_104370 => N_104357__F_104447 + N_104357__F_104370 => N_104357__F_104453 + N_104357__F_104371 => N_104357__F_104415 + N_104357__F_104371 => N_104357__F_104431 + N_104357__F_104371 => N_104357__F_104438 + N_104357__F_104371 => N_104357__F_104442 + N_104357__F_104371 => N_104357__F_104447 + N_104357__F_104371 => N_104357__F_104451 + N_104357__F_104372 => N_104357__F_104415 + N_104357__F_104372 => N_104357__F_104431 + N_104357__F_104372 => N_104357__F_104435 + N_104357__F_104372 => N_104357__F_104442 + N_104357__F_104372 => N_104357__F_104447 + N_104357__F_104372 => N_104357__F_104451 + !(N_104357__F_104372 & N_104357__F_104406) + N_104357__F_104373 => N_104357__F_104416 + N_104357__F_104373 => N_104357__F_104428 + N_104357__F_104373 => N_104357__F_104435 + N_104357__F_104373 => N_104357__F_104442 + N_104357__F_104373 => N_104357__F_104449 + N_104357__F_104373 => N_104357__F_104452 + !(N_104357__F_104373 & N_104357__F_104406) + N_104357__F_104374 => N_104357__F_104419 + N_104357__F_104374 => N_104357__F_104435 + N_104357__F_104374 => N_104357__F_104442 + N_104357__F_104374 => N_104357__F_104429 + N_104357__F_104374 => N_104357__F_104447 + N_104357__F_104374 => N_104357__F_104453 + !(N_104357__F_104374 & N_104357__F_104406) + N_104357__F_104375 => N_104357__F_104419 + N_104357__F_104375 => N_104357__F_104429 + N_104357__F_104375 => N_104357__F_104435 + N_104357__F_104375 => N_104357__F_104443 + N_104357__F_104375 => N_104357__F_104447 + N_104357__F_104375 => N_104357__F_104453 + N_104357__F_104376 => N_104357__F_104419 + N_104357__F_104376 => N_104357__F_104431 + N_104357__F_104376 => N_104357__F_104435 + N_104357__F_104376 => N_104357__F_104442 + N_104357__F_104376 => N_104357__F_104447 + N_104357__F_104376 => N_104357__F_104453 + N_104357__F_104377 => N_104357__F_104422 + N_104357__F_104377 => N_104357__F_104430 + N_104357__F_104377 => N_104357__F_104440 + N_104357__F_104377 => N_104357__F_104444 + N_104357__F_104377 => N_104357__F_104449 + N_104357__F_104377 => N_104357__F_104451 + N_104357__F_104378 => N_104357__F_104422 + N_104357__F_104378 => N_104357__F_104430 + N_104357__F_104378 => N_104357__F_104440 + N_104357__F_104378 => N_104357__F_104444 + N_104357__F_104378 => N_104357__F_104449 + N_104357__F_104378 => N_104357__F_104452 + N_104357__F_104379 => N_104357__F_104422 + N_104357__F_104379 => N_104357__F_104431 + N_104357__F_104379 => N_104357__F_104440 + N_104357__F_104379 => N_104357__F_104444 + N_104357__F_104379 => N_104357__F_104449 + N_104357__F_104379 => N_104357__F_104451 + N_104357__F_104380 => N_104357__F_104423 + N_104357__F_104380 => N_104357__F_104431 + N_104357__F_104380 => N_104357__F_104439 + N_104357__F_104380 => N_104357__F_104442 + N_104357__F_104380 => N_104357__F_104447 + N_104357__F_104380 => N_104357__F_104453 + N_104357__F_104381 => N_104357__F_104425 + N_104357__F_104381 => N_104357__F_104431 + N_104357__F_104381 => N_104357__F_104439 + N_104357__F_104381 => N_104357__F_104443 + N_104357__F_104381 => N_104357__F_104447 + N_104357__F_104381 => N_104357__F_104451 + N_104357__F_104382 => N_104357__F_104426 + N_104357__F_104382 => N_104357__F_104429 + N_104357__F_104382 => N_104357__F_104436 + N_104357__F_104382 => N_104357__F_104442 + N_104357__F_104382 => N_104357__F_104447 + N_104357__F_104382 => N_104357__F_104452 + !(N_104357__F_104382 & N_104357__F_104406) + !(N_104536__F_104539 & N_104536__F_104547) + !(N_104536__F_104539 & N_104536__F_104548) + N_104536__F_104539 => N_104700__F_104709 + N_104536__F_104539 => "N_104687__F_104691" + N_104536__F_104539 => "N_104687__F_104694" + !(N_104536__F_104540 & N_104536__F_104547) + !(N_104536__F_104540 & N_104536__F_104548) + N_104536__F_104540 => N_104700__F_104711 + N_104536__F_104540 => N_104700__F_104712 + N_104536__F_104540 => N_104700__F_104713 + N_104536__F_104540 => N_104700__F_104714 + N_104536__F_104540 => N_104700__F_104715 + N_104536__F_104540 => N_104700__F_104716 + N_104536__F_104540 => N_104700__F_104717 + N_104536__F_104540 => N_104700__F_104710 + N_104536__F_104540 => "N_104687__F_104691" + N_104536__F_104540 => "N_104687__F_104694" + !(N_104536__F_104541 & N_104536__F_104547) + !(N_104536__F_104541 & N_104536__F_104548) + N_104536__F_104541 => N_104700__F_104710 + N_104536__F_104541 => N_104700__F_104711 + N_104536__F_104541 => N_104700__F_104712 + N_104536__F_104541 => N_104700__F_104713 + N_104536__F_104541 => N_104700__F_104714 + N_104536__F_104541 => N_104700__F_104715 + N_104536__F_104541 => N_104700__F_104716 + N_104536__F_104541 => N_104700__F_104717 + N_104536__F_104541 => N_104687__F_104697 + N_104536__F_104541 => N_104687__F_104698 + !(N_104536__F_104542 & N_104536__F_104548) + N_104536__F_104542 => N_104700__F_104703 + N_104536__F_104542 => N_104700__F_104704 + N_104536__F_104542 => N_104700__F_104705 + N_104536__F_104542 => "N_104687__F_104691" + N_104536__F_104542 => "N_104687__F_104694" + !(N_104536__F_104543 & N_104536__F_104547) + N_104536__F_104543 => N_104700__F_104723 + N_104536__F_104543 => "N_104687__F_104691" + N_104536__F_104543 => "N_104687__F_104694" + !(N_104536__F_104544 & N_104536__F_104547) + !(N_104536__F_104544 & N_104536__F_104548) + N_104536__F_104544 => N_104700__F_104721 + !(N_104536__F_104545 & N_104536__F_104547) + !(N_104536__F_104545 & N_104536__F_104548) + N_104536__F_104545 => N_104700__F_104719 + N_104536__F_104547 => N_104700__F_104703 + N_104536__F_104547 => N_104700__F_104704 + N_104536__F_104547 => N_104700__F_104705 + N_104536__F_104547 => "N_104687__F_104691" + N_104536__F_104547 => "N_104687__F_104694" + N_104536__F_104548 => N_104700__F_104723 + N_104536__F_104548 => "N_104687__F_104691" + N_104536__F_104548 => "N_104687__F_104694" + !(N_104642__F_104645 & N_104642__F_104647) + N_104642__F_104646 => N_104642__F_104647 + N_104649__F_104652 => N_104649__F_104666 + N_104649__F_104652 => N_104649__F_104759 + N_104649__F_104652 => N_104649__F_104675 + N_104649__F_104652 => N_104649__F_104681 + N_104649__F_104653 => N_104649__F_104666 + "N_104649__F_104728" => N_100130__F_100280 + N_100300__F_100306 => N_100300__F_100324 + N_100300__F_100307 => N_100300__F_100324 + N_100300__F_100309 => N_100300__F_100324 + N_100300__F_100310 => N_100300__F_100324 + N_100469__I_100473_i_F_100474 => "N_104536__I_104551_i_F_104549" + N_100469__I_100473_i_F_100477 => "N_104536__I_104566_i_F_104564" + N_100469__I_100473_i_F_100480 => "N_104536__I_104581_i_F_104579" + N_100469__I_100473_i_F_100483 => "N_104536__I_104596_i_F_104594" + N_100469__I_100473_i_F_100486 => "N_104536__I_104611_i_F_104609" + N_100469__I_100473_i_F_100489 => "N_104536__I_104626_i_F_104624" + !(N_100000__I_100877_i_F_100959 & N_104687__F_104698) + !(N_100000__I_100976_i_F_101058 & N_104687__F_104698) + !(N_100000__I_101075_i_F_101157 & N_104687__F_104698) + !(N_100000__I_101174_i_F_101256 & N_104687__F_104698) + N_101764__F_101767 => "N_101764__F_101798" + N_101764__F_101767 => "N_101764__F_101783" + N_101764__F_101767 => "N_101764__F_101810" + N_101764__F_101767 => "N_101764__F_101835" + N_101764__F_101767 => "N_101764__F_101793" + N_101764__F_101767 => "N_101764__F_101799" + N_101764__F_101767 => N_101764__F_101805 + N_101764__F_101767 => "N_101764__F_101836" + N_101764__F_101767 => "N_101764__F_101846" + N_101764__F_101767 => "N_101764__F_101856" + N_101764__F_101767 => "N_101764__I_101839_i_F_101837" + N_101764__F_101767 => "N_101764__I_101849_i_F_101847" + N_101764__F_101767 => "N_101764__I_101859_i_F_101857" + N_101764__F_101767 => N_101764__I_101839_i_F_101840 + N_101764__F_101767 => N_101764__I_101849_i_F_101850 + N_101764__F_101767 => N_101764__I_101859_i_F_101860 + N_101764__F_101767 => N_101764__I_101816_i_F_101820 + N_101764__F_101767 => N_101764__I_101870_i_F_101871 + N_101764__F_101767 => N_101764__I_101870_i_F_101874 + N_101764__F_101767 => N_101764__I_101883_i_F_101884 + N_101764__F_101767 => N_101764__I_101883_i_F_101887 + N_101764__F_101767 => N_101764__I_101896_i_F_101897 + N_101764__F_101767 => N_101764__I_101896_i_F_101900 + N_101764__F_101767 => "N_101764__F_101866" + N_101764__F_101767 => "N_101764__F_101867" + N_101764__F_101767 => "N_101764__I_101870_i_F_101868" + N_101764__F_101767 => "N_101764__F_101880" + N_101764__F_101767 => "N_101764__I_101883_i_F_101881" + N_101764__F_101767 => "N_101764__F_101893" + N_101764__F_101767 => "N_101764__I_101896_i_F_101894" + N_101764__F_101768 => "N_101764__F_101783" + N_101764__F_101768 => "N_101764__F_101793" + N_101764__F_101768 => "N_101764__F_101808" + N_101764__F_101768 => N_101764__F_101809 + N_101764__F_101768 => "N_101764__F_101807" + N_101764__F_101768 => "N_101764__F_101810" + N_101764__F_101768 => "N_101764__I_101816_i_F_101814" + N_101764__F_101768 => N_101764__I_101816_i_F_101823 + N_101764__F_101768 => "N_101764__F_101835" + N_101764__F_101768 => "N_101764__F_101836" + N_101764__F_101768 => "N_101764__I_101839_i_F_101837" + N_101764__F_101768 => N_101764__I_101839_i_F_101840 + N_101764__F_101768 => "N_101764__F_101846" + N_101764__F_101768 => "N_101764__I_101849_i_F_101847" + N_101764__F_101768 => N_101764__I_101849_i_F_101850 + N_101764__F_101768 => "N_101764__F_101856" + N_101764__F_101768 => "N_101764__I_101859_i_F_101857" + N_101764__F_101768 => N_101764__I_101859_i_F_101860 + N_101764__F_101768 => N_101764__I_101870_i_F_101871 + N_101764__F_101768 => N_101764__I_101870_i_F_101874 + N_101764__F_101768 => N_101764__I_101883_i_F_101884 + N_101764__F_101768 => N_101764__I_101883_i_F_101887 + N_101764__F_101768 => N_101764__I_101896_i_F_101897 + N_101764__F_101768 => N_101764__I_101896_i_F_101900 + N_101764__F_101768 => "N_101764__F_101867" + N_101764__F_101768 => "N_101764__I_101870_i_F_101868" + N_101764__F_101768 => "N_101764__F_101880" + N_101764__F_101768 => "N_101764__I_101883_i_F_101881" + N_101764__F_101768 => "N_101764__F_101893" + N_101764__F_101768 => "N_101764__I_101896_i_F_101894" + N_101764__F_101768 => "N_101764__F_101866" + N_101764__F_101769 => "N_101764__F_101807" + N_101764__F_101769 => "N_101764__F_101783" + N_101764__F_101769 => "N_101764__F_101793" + N_101764__F_101769 => "N_101764__F_101810" + N_101764__F_101769 => "N_101764__F_101835" + N_101764__F_101769 => "N_101764__F_101808" + N_101764__F_101769 => N_101764__F_101809 + N_101764__F_101769 => "N_101764__F_101836" + N_101764__F_101769 => "N_101764__F_101846" + N_101764__F_101769 => "N_101764__F_101856" + N_101764__F_101769 => "N_101764__I_101839_i_F_101837" + N_101764__F_101769 => "N_101764__I_101849_i_F_101847" + N_101764__F_101769 => "N_101764__I_101859_i_F_101857" + N_101764__F_101769 => N_101764__I_101839_i_F_101840 + N_101764__F_101769 => N_101764__I_101849_i_F_101850 + N_101764__F_101769 => N_101764__I_101859_i_F_101860 + N_101764__F_101769 => N_101764__I_101816_i_F_101823 + N_101764__F_101769 => N_101764__I_101870_i_F_101871 + N_101764__F_101769 => N_101764__I_101870_i_F_101874 + N_101764__F_101769 => N_101764__I_101883_i_F_101884 + N_101764__F_101769 => N_101764__I_101883_i_F_101887 + N_101764__F_101769 => N_101764__I_101896_i_F_101897 + N_101764__F_101769 => N_101764__I_101896_i_F_101900 + N_101764__F_101769 => "N_101764__F_101866" + N_101764__F_101769 => "N_101764__F_101867" + N_101764__F_101769 => "N_101764__I_101870_i_F_101868" + N_101764__F_101769 => "N_101764__F_101880" + N_101764__F_101769 => "N_101764__I_101883_i_F_101881" + N_101764__F_101769 => "N_101764__F_101893" + N_101764__F_101769 => "N_101764__I_101896_i_F_101894" + N_101764__F_101770 => "N_101764__F_101783" + N_101764__F_101770 => "N_101764__F_101793" + N_101764__F_101770 => "N_101764__F_101807" + N_101764__F_101770 => "N_101764__F_101808" + N_101764__F_101770 => N_101764__F_101809 + N_101764__F_101770 => "N_101764__F_101810" + N_101764__F_101770 => "N_101764__I_101816_i_F_101814" + N_101764__F_101770 => N_101764__I_101816_i_F_101823 + N_101764__F_101770 => "N_101764__F_101835" + N_101764__F_101770 => "N_101764__F_101836" + N_101764__F_101770 => "N_101764__I_101839_i_F_101837" + N_101764__F_101770 => N_101764__I_101839_i_F_101840 + N_101764__F_101770 => "N_101764__F_101846" + N_101764__F_101770 => "N_101764__I_101849_i_F_101847" + N_101764__F_101770 => N_101764__I_101849_i_F_101850 + N_101764__F_101770 => "N_101764__F_101856" + N_101764__F_101770 => "N_101764__I_101859_i_F_101857" + N_101764__F_101770 => N_101764__I_101859_i_F_101860 + N_101764__F_101770 => N_101764__I_101870_i_F_101871 + N_101764__F_101770 => N_101764__I_101870_i_F_101874 + N_101764__F_101770 => N_101764__I_101883_i_F_101884 + N_101764__F_101770 => N_101764__I_101883_i_F_101887 + N_101764__F_101770 => N_101764__I_101896_i_F_101897 + N_101764__F_101770 => N_101764__I_101896_i_F_101900 + N_101764__F_101770 => "N_101764__F_101866" + N_101764__F_101770 => "N_101764__F_101867" + N_101764__F_101770 => "N_101764__I_101870_i_F_101868" + N_101764__F_101770 => "N_101764__F_101880" + N_101764__F_101770 => "N_101764__I_101883_i_F_101881" + N_101764__F_101770 => "N_101764__F_101893" + N_101764__F_101770 => "N_101764__I_101896_i_F_101894" + N_101764__F_101771 => "N_101764__F_101798" + N_101764__F_101771 => "N_101764__F_101783" + N_101764__F_101771 => "N_101764__F_101793" + N_101764__F_101771 => "N_101764__F_101799" + N_101764__F_101771 => N_101764__F_101800 + N_101764__F_101771 => "N_101764__F_101810" + N_101764__F_101771 => "N_101764__F_101835" + N_101764__F_101771 => "N_101764__F_101836" + N_101764__F_101771 => "N_101764__F_101846" + N_101764__F_101771 => "N_101764__F_101856" + N_101764__F_101771 => "N_101764__I_101839_i_F_101837" + N_101764__F_101771 => "N_101764__I_101849_i_F_101847" + N_101764__F_101771 => "N_101764__I_101859_i_F_101857" + N_101764__F_101771 => N_101764__I_101839_i_F_101840 + N_101764__F_101771 => N_101764__I_101849_i_F_101850 + N_101764__F_101771 => N_101764__I_101859_i_F_101860 + N_101764__F_101771 => N_101764__I_101816_i_F_101832 + N_101764__F_101771 => N_101764__I_101870_i_F_101871 + N_101764__F_101771 => N_101764__I_101870_i_F_101874 + N_101764__F_101771 => N_101764__I_101883_i_F_101884 + N_101764__F_101771 => N_101764__I_101883_i_F_101887 + N_101764__F_101771 => N_101764__I_101896_i_F_101897 + N_101764__F_101771 => N_101764__I_101896_i_F_101900 + N_101764__F_101771 => "N_101764__F_101866" + N_101764__F_101771 => "N_101764__F_101867" + N_101764__F_101771 => "N_101764__I_101870_i_F_101868" + N_101764__F_101771 => "N_101764__F_101880" + N_101764__F_101771 => "N_101764__I_101883_i_F_101881" + N_101764__F_101771 => "N_101764__F_101893" + N_101764__F_101771 => "N_101764__I_101896_i_F_101894" + N_101764__F_101772 => N_101764__I_101816_i_F_101817 + N_101764__F_101772 => N_101764__F_101803 + N_101764__F_101772 => N_101764__I_101839_i_F_101840 + N_101764__F_101772 => N_101764__I_101849_i_F_101850 + N_101764__F_101772 => N_101764__I_101859_i_F_101860 + N_101764__F_101772 => "N_101764__F_101783" + N_101764__F_101772 => "N_101764__F_101793" + N_101764__F_101772 => "N_101764__F_101798" + N_101764__F_101772 => "N_101764__F_101810" + N_101764__F_101772 => "N_101764__I_101816_i_F_101814" + N_101764__F_101772 => "N_101764__F_101835" + N_101764__F_101772 => "N_101764__I_101839_i_F_101837" + N_101764__F_101772 => "N_101764__I_101859_i_F_101857" + N_101764__F_101772 => "N_101764__F_101836" + N_101764__F_101772 => "N_101764__I_101849_i_F_101847" + N_101764__F_101772 => "N_101764__F_101846" + N_101764__F_101772 => "N_101764__F_101856" + N_101764__F_101772 => N_101764__I_101870_i_F_101871 + N_101764__F_101772 => N_101764__I_101870_i_F_101874 + N_101764__F_101772 => N_101764__I_101883_i_F_101884 + N_101764__F_101772 => N_101764__I_101883_i_F_101887 + N_101764__F_101772 => N_101764__I_101896_i_F_101897 + N_101764__F_101772 => N_101764__I_101896_i_F_101900 + N_101764__F_101772 => "N_101764__F_101866" + N_101764__F_101772 => "N_101764__F_101867" + N_101764__F_101772 => "N_101764__I_101870_i_F_101868" + N_101764__F_101772 => "N_101764__F_101880" + N_101764__F_101772 => "N_101764__I_101883_i_F_101881" + N_101764__F_101772 => "N_101764__F_101893" + N_101764__F_101772 => "N_101764__I_101896_i_F_101894" + N_101764__F_101773 => "N_101764__F_101783" + N_101764__F_101773 => "N_101764__F_101793" + N_101764__F_101773 => "N_101764__F_101798" + N_101764__F_101773 => "N_101764__F_101799" + N_101764__F_101773 => N_101764__F_101803 + N_101764__F_101773 => "N_101764__F_101835" + N_101764__F_101773 => "N_101764__F_101836" + N_101764__F_101773 => "N_101764__I_101839_i_F_101837" + N_101764__F_101773 => N_101764__I_101839_i_F_101840 + N_101764__F_101773 => "N_101764__F_101846" + N_101764__F_101773 => "N_101764__I_101849_i_F_101847" + N_101764__F_101773 => N_101764__I_101849_i_F_101850 + N_101764__F_101773 => "N_101764__F_101856" + N_101764__F_101773 => "N_101764__I_101859_i_F_101857" + N_101764__F_101773 => N_101764__I_101859_i_F_101860 + N_101764__F_101773 => N_101764__I_101870_i_F_101871 + N_101764__F_101773 => N_101764__I_101870_i_F_101874 + N_101764__F_101773 => N_101764__I_101883_i_F_101884 + N_101764__F_101773 => N_101764__I_101883_i_F_101887 + N_101764__F_101773 => N_101764__I_101896_i_F_101897 + N_101764__F_101773 => N_101764__I_101896_i_F_101900 + N_101764__F_101773 => "N_101764__F_101866" + N_101764__F_101773 => "N_101764__F_101867" + N_101764__F_101773 => "N_101764__I_101870_i_F_101868" + N_101764__F_101773 => "N_101764__F_101880" + N_101764__F_101773 => "N_101764__I_101883_i_F_101881" + N_101764__F_101773 => "N_101764__F_101893" + N_101764__F_101773 => "N_101764__I_101896_i_F_101894" + N_101764__F_101773 => "N_101764__F_101810" + N_101764__F_101773 => "N_101764__I_101816_i_F_101814" + N_101764__F_101774 => "N_101764__F_101784" + N_101764__F_101774 => N_101764__F_101787 + N_101764__F_101774 => N_101764__F_101813 + N_101764__F_101774 => "N_101764__F_101783" + N_101764__F_101774 => "N_101764__F_101785" + N_101764__F_101774 => "N_101764__F_101810" + N_101764__F_101774 => "N_101764__F_101811" + N_101764__F_101774 => N_101764__F_101813 + N_101764__F_101774 => "N_101764__F_101835" + N_101764__F_101774 => "N_101764__F_101836" + N_101764__F_101774 => "N_101764__F_101846" + N_101764__F_101774 => "N_101764__F_101856" + N_101764__F_101774 => "N_101764__I_101839_i_F_101837" + N_101764__F_101774 => "N_101764__I_101849_i_F_101847" + N_101764__F_101774 => "N_101764__I_101859_i_F_101857" + N_101764__F_101774 => N_101764__I_101839_i_F_101840 + N_101764__F_101774 => N_101764__I_101849_i_F_101850 + N_101764__F_101774 => N_101764__I_101859_i_F_101860 + N_101764__F_101774 => N_101764__I_101859_i_F_101863 + N_101764__F_101774 => N_101764__F_101792 + N_101764__F_101774 => N_101764__I_101870_i_F_101871 + N_101764__F_101774 => N_101764__I_101870_i_F_101874 + N_101764__F_101774 => N_101764__I_101883_i_F_101884 + N_101764__F_101774 => N_101764__I_101883_i_F_101887 + N_101764__F_101774 => N_101764__I_101896_i_F_101897 + N_101764__F_101774 => N_101764__I_101896_i_F_101900 + N_101764__F_101774 => "N_101764__F_101866" + N_101764__F_101774 => "N_101764__F_101867" + N_101764__F_101774 => "N_101764__I_101870_i_F_101868" + N_101764__F_101774 => "N_101764__F_101880" + N_101764__F_101774 => "N_101764__I_101883_i_F_101881" + N_101764__F_101774 => "N_101764__F_101893" + N_101764__F_101774 => "N_101764__I_101896_i_F_101894" + N_101764__F_101775 => "N_101764__F_101784" + N_101764__F_101775 => "N_101764__F_101810" + N_101764__F_101775 => "N_101764__F_101811" + N_101764__F_101775 => "N_101764__F_101835" + N_101764__F_101775 => "N_101764__F_101836" + N_101764__F_101775 => "N_101764__F_101846" + N_101764__F_101775 => "N_101764__I_101839_i_F_101837" + N_101764__F_101775 => "N_101764__I_101849_i_F_101847" + N_101764__F_101775 => N_101764__I_101839_i_F_101840 + N_101764__F_101775 => N_101764__I_101849_i_F_101850 + N_101764__F_101775 => "N_101764__F_101783" + N_101764__F_101775 => N_101764__F_101788 + N_101764__F_101775 => "N_101764__F_101785" + N_101764__F_101775 => N_101764__I_101870_i_F_101871 + N_101764__F_101775 => N_101764__I_101870_i_F_101874 + N_101764__F_101775 => N_101764__I_101883_i_F_101884 + N_101764__F_101775 => N_101764__I_101883_i_F_101887 + N_101764__F_101775 => N_101764__I_101896_i_F_101897 + N_101764__F_101775 => N_101764__I_101896_i_F_101900 + N_101764__F_101775 => "N_101764__F_101866" + N_101764__F_101775 => "N_101764__F_101867" + N_101764__F_101775 => "N_101764__I_101870_i_F_101868" + N_101764__F_101775 => "N_101764__F_101880" + N_101764__F_101775 => "N_101764__I_101883_i_F_101881" + N_101764__F_101775 => "N_101764__F_101893" + N_101764__F_101775 => "N_101764__I_101896_i_F_101894" + N_101764__F_101776 => "N_101764__F_101784" + N_101764__F_101776 => "N_101764__F_101810" + N_101764__F_101776 => "N_101764__F_101811" + N_101764__F_101776 => "N_101764__F_101835" + N_101764__F_101776 => "N_101764__F_101836" + N_101764__F_101776 => "N_101764__F_101846" + N_101764__F_101776 => "N_101764__I_101839_i_F_101837" + N_101764__F_101776 => "N_101764__I_101849_i_F_101847" + N_101764__F_101776 => N_101764__I_101839_i_F_101840 + N_101764__F_101776 => N_101764__I_101849_i_F_101850 + N_101764__F_101776 => "N_101764__F_101783" + N_101764__F_101776 => N_101764__F_101789 + N_101764__F_101776 => "N_101764__F_101785" + N_101764__F_101776 => N_101764__I_101870_i_F_101871 + N_101764__F_101776 => N_101764__I_101870_i_F_101874 + N_101764__F_101776 => N_101764__I_101883_i_F_101884 + N_101764__F_101776 => N_101764__I_101883_i_F_101887 + N_101764__F_101776 => N_101764__I_101896_i_F_101897 + N_101764__F_101776 => N_101764__I_101896_i_F_101900 + N_101764__F_101776 => "N_101764__F_101866" + N_101764__F_101776 => "N_101764__F_101867" + N_101764__F_101776 => "N_101764__I_101870_i_F_101868" + N_101764__F_101776 => "N_101764__F_101880" + N_101764__F_101776 => "N_101764__I_101883_i_F_101881" + N_101764__F_101776 => "N_101764__F_101893" + N_101764__F_101776 => "N_101764__I_101896_i_F_101894" + N_101764__F_101777 => "N_101764__F_101784" + N_101764__F_101777 => "N_101764__F_101810" + N_101764__F_101777 => "N_101764__F_101811" + N_101764__F_101777 => "N_101764__F_101835" + N_101764__F_101777 => "N_101764__F_101836" + N_101764__F_101777 => "N_101764__F_101846" + N_101764__F_101777 => "N_101764__F_101856" + N_101764__F_101777 => "N_101764__I_101839_i_F_101837" + N_101764__F_101777 => "N_101764__I_101849_i_F_101847" + N_101764__F_101777 => "N_101764__I_101859_i_F_101857" + N_101764__F_101777 => N_101764__I_101839_i_F_101840 + N_101764__F_101777 => N_101764__I_101849_i_F_101850 + N_101764__F_101777 => "N_101764__F_101783" + N_101764__F_101777 => "N_101764__F_101785" + N_101764__F_101777 => N_101764__F_101790 + N_101764__F_101777 => N_101764__F_101812 + N_101764__F_101777 => N_101764__I_101859_i_F_101860 + N_101764__F_101777 => N_101764__F_101792 + N_101764__F_101777 => N_101764__I_101870_i_F_101871 + N_101764__F_101777 => N_101764__I_101870_i_F_101874 + N_101764__F_101777 => N_101764__I_101883_i_F_101884 + N_101764__F_101777 => N_101764__I_101883_i_F_101887 + N_101764__F_101777 => N_101764__I_101896_i_F_101897 + N_101764__F_101777 => N_101764__I_101896_i_F_101900 + N_101764__F_101777 => "N_101764__F_101866" + N_101764__F_101777 => "N_101764__F_101867" + N_101764__F_101777 => "N_101764__I_101870_i_F_101868" + N_101764__F_101777 => "N_101764__F_101880" + N_101764__F_101777 => "N_101764__I_101883_i_F_101881" + N_101764__F_101777 => "N_101764__F_101893" + N_101764__F_101777 => "N_101764__I_101896_i_F_101894" + N_101764__F_101778 => "N_101764__F_101783" + N_101764__F_101778 => "N_101764__F_101784" + N_101764__F_101778 => "N_101764__F_101785" + N_101764__F_101778 => N_101764__F_101786 + N_101764__F_101778 => "N_101764__F_101810" + N_101764__F_101778 => "N_101764__F_101811" + N_101764__F_101778 => N_101764__F_101812 + N_101764__F_101778 => "N_101764__F_101835" + N_101764__F_101778 => "N_101764__F_101856" + N_101764__F_101778 => "N_101764__I_101859_i_F_101857" + N_101764__F_101778 => N_101764__I_101859_i_F_101860 + N_101764__F_101778 => N_101764__I_101870_i_F_101871 + N_101764__F_101778 => N_101764__I_101870_i_F_101874 + N_101764__F_101778 => N_101764__I_101883_i_F_101884 + N_101764__F_101778 => N_101764__I_101883_i_F_101887 + N_101764__F_101778 => N_101764__I_101896_i_F_101897 + N_101764__F_101778 => N_101764__I_101896_i_F_101900 + N_101764__F_101778 => "N_101764__F_101866" + N_101764__F_101778 => "N_101764__F_101867" + N_101764__F_101778 => "N_101764__I_101870_i_F_101868" + N_101764__F_101778 => "N_101764__F_101880" + N_101764__F_101778 => "N_101764__I_101883_i_F_101881" + N_101764__F_101778 => "N_101764__F_101893" + N_101764__F_101778 => "N_101764__I_101896_i_F_101894" + N_101764__F_101779 => "N_101764__F_101783" + N_101764__F_101779 => "N_101764__F_101784" + N_101764__F_101779 => "N_101764__F_101785" + N_101764__F_101779 => N_101764__F_101790 + N_101764__F_101779 => N_101764__F_101792 + N_101764__F_101779 => "N_101764__F_101810" + N_101764__F_101779 => "N_101764__F_101811" + N_101764__F_101779 => N_101764__F_101812 + N_101764__F_101779 => "N_101764__F_101835" + N_101764__F_101779 => "N_101764__F_101836" + N_101764__F_101779 => "N_101764__I_101839_i_F_101837" + N_101764__F_101779 => N_101764__I_101839_i_F_101840 + N_101764__F_101779 => "N_101764__F_101846" + N_101764__F_101779 => "N_101764__I_101849_i_F_101847" + N_101764__F_101779 => N_101764__I_101849_i_F_101850 + N_101764__F_101779 => "N_101764__F_101856" + N_101764__F_101779 => "N_101764__I_101859_i_F_101857" + N_101764__F_101779 => N_101764__I_101859_i_F_101860 + N_101764__F_101779 => N_101764__I_101870_i_F_101871 + N_101764__F_101779 => N_101764__I_101870_i_F_101874 + N_101764__F_101779 => N_101764__I_101883_i_F_101884 + N_101764__F_101779 => N_101764__I_101883_i_F_101887 + N_101764__F_101779 => N_101764__I_101896_i_F_101897 + N_101764__F_101779 => N_101764__I_101896_i_F_101900 + N_101764__F_101779 => "N_101764__F_101866" + N_101764__F_101779 => "N_101764__F_101867" + N_101764__F_101779 => "N_101764__I_101870_i_F_101868" + N_101764__F_101779 => "N_101764__F_101880" + N_101764__F_101779 => "N_101764__I_101883_i_F_101881" + N_101764__F_101779 => "N_101764__F_101893" + N_101764__F_101779 => "N_101764__I_101896_i_F_101894" + N_101764__F_101780 => "N_101764__F_101783" + N_101764__F_101780 => "N_101764__F_101784" + N_101764__F_101780 => "N_101764__F_101785" + N_101764__F_101780 => N_101764__F_101786 + N_101764__F_101780 => N_101764__F_101792 + N_101764__F_101780 => "N_101764__F_101810" + N_101764__F_101780 => "N_101764__F_101811" + N_101764__F_101780 => N_101764__F_101812 + N_101764__F_101780 => "N_101764__F_101835" + N_101764__F_101780 => "N_101764__F_101856" + N_101764__F_101780 => "N_101764__I_101859_i_F_101857" + N_101764__F_101780 => N_101764__I_101859_i_F_101860 + N_101764__F_101780 => N_101764__I_101870_i_F_101871 + N_101764__F_101780 => N_101764__I_101870_i_F_101874 + N_101764__F_101780 => N_101764__I_101883_i_F_101884 + N_101764__F_101780 => N_101764__I_101883_i_F_101887 + N_101764__F_101780 => N_101764__I_101896_i_F_101897 + N_101764__F_101780 => N_101764__I_101896_i_F_101900 + N_101764__F_101780 => "N_101764__F_101866" + N_101764__F_101780 => "N_101764__F_101867" + N_101764__F_101780 => "N_101764__I_101870_i_F_101868" + N_101764__F_101780 => "N_101764__F_101880" + N_101764__F_101780 => "N_101764__I_101883_i_F_101881" + N_101764__F_101780 => "N_101764__F_101893" + N_101764__F_101780 => "N_101764__I_101896_i_F_101894" + N_101764__F_101781 => "N_101764__F_101783" + N_101764__F_101781 => "N_101764__F_101784" + N_101764__F_101781 => "N_101764__F_101785" + N_101764__F_101781 => "N_101764__F_101785" + N_101764__F_101781 => N_101764__F_101787 + N_101764__F_101781 => N_101764__F_101792 + N_101764__F_101781 => "N_101764__F_101810" + N_101764__F_101781 => "N_101764__F_101811" + N_101764__F_101781 => N_101764__F_101813 + N_101764__F_101781 => "N_101764__F_101835" + N_101764__F_101781 => "N_101764__F_101836" + N_101764__F_101781 => "N_101764__I_101839_i_F_101837" + N_101764__F_101781 => N_101764__I_101839_i_F_101840 + N_101764__F_101781 => "N_101764__F_101846" + N_101764__F_101781 => "N_101764__I_101849_i_F_101847" + N_101764__F_101781 => N_101764__I_101849_i_F_101850 + N_101764__F_101781 => "N_101764__F_101856" + N_101764__F_101781 => "N_101764__I_101859_i_F_101857" + N_101764__F_101781 => N_101764__I_101859_i_F_101860 + N_101764__F_101781 => N_101764__I_101870_i_F_101871 + N_101764__F_101781 => N_101764__I_101870_i_F_101874 + N_101764__F_101781 => N_101764__I_101883_i_F_101884 + N_101764__F_101781 => N_101764__I_101883_i_F_101887 + N_101764__F_101781 => N_101764__I_101896_i_F_101897 + N_101764__F_101781 => N_101764__I_101896_i_F_101900 + N_101764__F_101781 => "N_101764__F_101866" + N_101764__F_101781 => "N_101764__F_101867" + N_101764__F_101781 => "N_101764__I_101870_i_F_101868" + N_101764__F_101781 => "N_101764__F_101880" + N_101764__F_101781 => "N_101764__I_101883_i_F_101881" + N_101764__F_101781 => "N_101764__F_101893" + N_101764__F_101781 => "N_101764__I_101896_i_F_101894" + N_101764__F_101782 => "N_101764__F_101783" + N_101764__F_101782 => "N_101764__F_101793" + N_101764__F_101782 => "N_101764__F_101794" + N_101764__F_101782 => "N_101764__F_101795" + N_101764__F_101782 => N_101764__F_101797 + N_101764__F_101782 => "N_101764__F_101810" + N_101764__F_101782 => "N_101764__I_101816_i_F_101814" + N_101764__F_101782 => N_101764__I_101816_i_F_101820 + N_101764__F_101782 => "N_101764__F_101835" + N_101764__F_101782 => "N_101764__I_101839_i_F_101837" + N_101764__F_101782 => N_101764__I_101839_i_F_101840 + N_101764__F_101782 => "N_101764__F_101846" + N_101764__F_101782 => "N_101764__I_101849_i_F_101847" + N_101764__F_101782 => N_101764__I_101849_i_F_101850 + N_101764__F_101782 => "N_101764__F_101856" + N_101764__F_101782 => "N_101764__I_101859_i_F_101857" + N_101764__F_101782 => N_101764__I_101859_i_F_101860 + N_101764__F_101782 => N_101764__I_101870_i_F_101871 + N_101764__F_101782 => N_101764__I_101870_i_F_101874 + N_101764__F_101782 => N_101764__I_101883_i_F_101884 + N_101764__F_101782 => N_101764__I_101883_i_F_101887 + N_101764__F_101782 => N_101764__I_101896_i_F_101897 + N_101764__F_101782 => N_101764__I_101896_i_F_101900 + N_101764__F_101782 => "N_101764__F_101866" + N_101764__F_101782 => "N_101764__F_101867" + N_101764__F_101782 => "N_101764__I_101870_i_F_101868" + N_101764__F_101782 => "N_101764__F_101880" + N_101764__F_101782 => "N_101764__I_101883_i_F_101881" + N_101764__F_101782 => "N_101764__F_101893" + N_101764__F_101782 => "N_101764__I_101896_i_F_101894" + N_101906__F_101909 => N_101906__F_101913 + N_101906__F_101909 => N_101906__F_101926 + N_101906__F_101909 => N_101906__F_101928 + N_101906__F_101910 => "N_101906__F_101915" + N_101906__F_101910 => N_101906__F_101926 + N_101906__F_101910 => N_101906__F_101928 + N_101906__F_101910 => N_101906__F_101916 + N_101906__F_101911 => N_101906__F_101913 + N_101906__F_101911 => N_101906__F_101926 + N_101906__F_101911 => N_101906__F_101928 + N_101906__F_101928 => N_104357__F_104385 + N_101906__F_101930 => N_100618__F_100708 + N_101906__F_101931 => N_100618__F_100709 + N_101932__F_101935 => "N_101932__F_101946" + N_101932__F_101935 => "N_101932__F_101954" + N_101932__F_101935 => N_101932__F_101961 + N_101932__F_101935 => "N_101932__F_101964" + N_101932__F_101935 => "N_101932__F_101986" + N_101932__F_101935 => N_101932__I_101967_i_F_101968 + N_101932__F_101935 => N_101932__F_101955 + N_101932__F_101935 => N_101932__I_101993_i_F_101994 + N_101932__F_101935 => N_101932__I_101993_i_F_101997 + N_101932__F_101935 => "N_101932__F_101990" + N_101932__F_101935 => "N_101932__I_101993_i_F_101991" + N_101932__F_101936 => "N_101932__F_101946" + N_101932__F_101936 => "N_101932__F_101954" + N_101932__F_101936 => N_101932__F_101957 + N_101932__F_101936 => "N_101932__F_101964" + N_101932__F_101936 => "N_101932__F_101986" + N_101932__F_101936 => N_101932__I_101967_i_F_101968 + N_101932__F_101936 => N_101932__F_101955 + N_101932__F_101936 => N_101932__I_101993_i_F_101994 + N_101932__F_101936 => N_101932__I_101993_i_F_101997 + N_101932__F_101936 => "N_101932__F_101990" + N_101932__F_101936 => "N_101932__I_101993_i_F_101991" + N_101932__F_101937 => "N_101932__F_101946" + N_101932__F_101937 => "N_101932__F_101954" + N_101932__F_101937 => N_101932__F_101959 + N_101932__F_101937 => "N_101932__F_101964" + N_101932__F_101937 => "N_101932__F_101986" + N_101932__F_101937 => N_101932__I_101967_i_F_101968 + N_101932__F_101937 => N_101932__F_101955 + N_101932__F_101937 => N_101932__I_101993_i_F_101994 + N_101932__F_101937 => N_101932__I_101993_i_F_101997 + N_101932__F_101937 => "N_101932__F_101990" + N_101932__F_101937 => "N_101932__I_101993_i_F_101991" + N_101932__F_101938 => "N_101932__F_101946" + N_101932__F_101938 => "N_101932__F_101954" + N_101932__F_101938 => N_101932__F_101955 + N_101932__F_101938 => N_101932__F_101956 + N_101932__F_101938 => "N_101932__F_101964" + N_101932__F_101938 => "N_101932__I_101967_i_F_101965" + N_101932__F_101938 => N_101932__I_101967_i_F_101968 + N_101932__F_101938 => N_101932__I_101993_i_F_101994 + N_101932__F_101938 => N_101932__I_101993_i_F_101997 + N_101932__F_101938 => "N_101932__F_101990" + N_101932__F_101938 => "N_101932__I_101993_i_F_101991" + N_101932__F_101939 => "N_101932__F_101946" + N_101932__F_101939 => "N_101932__F_101954" + N_101932__F_101939 => N_101932__F_101956 + N_101932__F_101939 => "N_101932__F_101964" + N_101932__F_101939 => "N_101932__F_101986" + N_101932__F_101939 => N_101932__I_101967_i_F_101974 + N_101932__F_101939 => N_101932__I_101993_i_F_101994 + N_101932__F_101939 => N_101932__I_101993_i_F_101997 + N_101932__F_101939 => "N_101932__F_101990" + N_101932__F_101939 => "N_101932__I_101993_i_F_101991" + N_101932__F_101940 => "N_101932__F_101946" + N_101932__F_101940 => "N_101932__F_101954" + N_101932__F_101940 => N_101932__F_101957 + N_101932__F_101940 => "N_101932__F_101964" + N_101932__F_101940 => "N_101932__F_101986" + N_101932__F_101940 => N_101932__I_101967_i_F_101974 + N_101932__F_101940 => N_101932__I_101993_i_F_101994 + N_101932__F_101940 => N_101932__I_101993_i_F_101997 + N_101932__F_101940 => "N_101932__F_101990" + N_101932__F_101940 => "N_101932__I_101993_i_F_101991" + N_101932__F_101941 => "N_101932__F_101946" + N_101932__F_101941 => "N_101932__F_101954" + N_101932__F_101941 => N_101932__F_101955 + N_101932__F_101941 => "N_101932__F_101964" + N_101932__F_101941 => "N_101932__I_101967_i_F_101965" + N_101932__F_101941 => N_101932__I_101967_i_F_101968 + N_101932__F_101941 => N_101932__I_101993_i_F_101994 + N_101932__F_101941 => N_101932__I_101993_i_F_101997 + N_101932__F_101941 => "N_101932__F_101990" + N_101932__F_101941 => "N_101932__I_101993_i_F_101991" + N_101932__F_101942 => "N_101932__F_101946" + N_101932__F_101942 => "N_101932__F_101954" + N_101932__F_101942 => N_101932__F_101962 + N_101932__F_101942 => "N_101932__F_101964" + N_101932__F_101942 => "N_101932__F_101986" + N_101932__F_101942 => N_101932__I_101967_i_F_101977 + N_101932__F_101942 => N_101932__F_101955 + N_101932__F_101942 => N_101932__I_101993_i_F_101994 + N_101932__F_101942 => N_101932__I_101993_i_F_101997 + N_101932__F_101942 => "N_101932__F_101990" + N_101932__F_101942 => "N_101932__I_101993_i_F_101991" + N_101932__F_101943 => "N_101932__F_101946" + N_101932__F_101943 => "N_101932__F_101954" + N_101932__F_101943 => N_101932__F_101955 + N_101932__F_101943 => "N_101932__F_101964" + N_101932__F_101943 => "N_101932__I_101967_i_F_101965" + N_101932__F_101943 => N_101932__I_101993_i_F_101994 + N_101932__F_101943 => N_101932__I_101993_i_F_101997 + N_101932__F_101943 => "N_101932__F_101990" + N_101932__F_101943 => "N_101932__I_101993_i_F_101991" + N_101932__F_101944 => "N_101932__F_101946" + N_101932__F_101944 => "N_101932__F_101947" + N_101932__F_101944 => N_101932__F_101949 + N_101932__F_101944 => "N_101932__F_101964" + N_101932__F_101944 => "N_101932__F_101986" + N_101932__F_101944 => "N_101932__F_101987" + N_101932__F_101944 => N_101932__I_101967_i_F_101968 + N_101932__F_101944 => N_101932__F_101948 + N_101932__F_101944 => N_101932__I_101993_i_F_102000 + N_101932__F_101944 => "N_101932__F_101990" + N_101932__F_101944 => "N_101932__I_101993_i_F_101991" + N_101932__F_101945 => "N_101932__F_101946" + N_101932__F_101945 => "N_101932__F_101947" + N_101932__F_101945 => N_101932__F_101948 + N_101932__F_101945 => N_101932__F_101950 + N_101932__F_101945 => "N_101932__F_101964" + N_101932__F_101945 => "N_101932__I_101967_i_F_101965" + N_101932__F_101945 => N_101932__I_101967_i_F_101968 + N_101932__F_101945 => "N_101932__F_101986" + N_101932__F_101945 => "N_101932__F_101987" + N_101932__F_101945 => N_101932__F_101988 + N_101932__F_101945 => N_101932__I_101993_i_F_102000 + N_101932__F_101945 => "N_101932__F_101990" + N_101932__F_101945 => "N_101932__I_101993_i_F_101991" + N_102004__F_102007 => N_102004__F_102015 + N_102004__F_102007 => N_102004__F_102017 + N_102004__F_102007 => "N_102004__F_102019" + N_102004__F_102007 => N_102004__F_102020 + N_102004__F_102007 => N_102004__F_102022 + N_102004__F_102007 => N_102004__F_102025 + N_102004__F_102007 => "N_100300__F_100330" + N_102004__F_102007 => N_104357__F_104387 + N_102004__F_102008 => N_100300__F_100326 + N_102004__F_102008 => N_102004__F_102015 + N_102004__F_102008 => N_102004__F_102017 + N_102004__F_102008 => N_102004__F_102020 + N_102004__F_102008 => N_102004__F_102022 + !(N_102004__F_102008 & "N_102004__F_102023") + N_102004__F_102008 => "N_102004__F_102019" + N_102004__F_102008 => N_104357__F_104388 + N_102004__F_102009 => N_102004__F_102012 + N_102004__F_102009 => N_102004__F_102017 + N_102004__F_102009 => N_102004__F_102022 + N_102004__F_102009 => "N_100300__F_100330" + N_102004__F_102009 => N_102004__F_102020 + !(N_102004__F_102009 & "N_102004__F_102023") + N_104284__F_104287 => N_104284__F_104296 + N_104284__F_104287 => N_104284__F_104302 + N_104284__F_104287 => N_104284__F_104310 + !(N_104284__F_104287 & "N_104284__F_104311") + N_104284__F_104287 => N_104284__F_104329 + N_104284__F_104287 => N_104284__F_104331 + N_104284__F_104287 => N_104284__F_104333 + N_104284__F_104288 => "N_104284__F_104291" + N_104284__F_104288 => N_104284__F_104309 + N_104284__F_104288 => N_104284__F_104329 + N_104284__F_104288 => N_104284__F_104293 + !(N_104284__F_104288 & "N_104284__F_104311") + N_104284__F_104288 => N_104284__F_104331 + N_104284__F_104288 => N_104284__F_104333 + !("N_104284__F_104311" & "N_104284__F_104297") + N_104334__F_104337 => N_104334__F_104344 + N_104334__F_104337 => N_104334__F_104347 + N_104334__F_104337 => N_104334__F_104351 + N_104334__F_104337 => N_104334__F_104353 + N_104334__F_104338 => N_104334__F_104344 + N_104334__F_104338 => N_104334__F_104347 + N_104334__F_104338 => N_104334__F_104350 + N_104334__F_104338 => N_104334__F_104353 + N_104334__F_104339 => N_104334__F_104344 + N_104334__F_104339 => N_104334__F_104348 + N_104334__F_104339 => N_104334__F_104351 + N_104334__F_104339 => N_104334__F_104353 + N_104334__F_104340 => N_104334__F_104345 + N_104334__F_104340 => N_104334__F_104348 + N_104334__F_104340 => N_104334__F_104350 + N_104334__F_104340 => N_104334__F_104353 + N_104334__F_104341 => N_104334__F_104345 + N_104334__F_104341 => N_104334__F_104354 + "N_104357__F_104521" => N_104357__F_104462 + "N_104357__F_104521" => N_104357__F_104516 + "N_104536__I_104551_i_F_104549" => "N_104649__F_104761" + "N_104536__I_104566_i_F_104564" => "N_104649__F_104775" + "N_104536__I_104581_i_F_104579" => "N_104649__I_104817_i_F_104815" + "N_104536__I_104596_i_F_104594" => "N_104536__F_104639" + "N_104536__I_104596_i_F_104594" => "N_104649__F_104761" + "N_104536__I_104611_i_F_104609" => "N_104536__F_104639" + "N_104536__I_104611_i_F_104609" => "N_104649__F_104775" + "N_104536__I_104626_i_F_104624" => "N_104536__F_104639" + "N_104536__I_104626_i_F_104624" => "N_104649__I_104817_i_F_104815" + N_100576__F_100579 => N_100576__F_100590 + N_100576__F_100579 => N_100576__F_100593 + N_100576__F_100579 => N_100576__F_100597 + N_100576__F_100579 => N_100576__F_100604 + N_100576__F_100579 => N_100576__F_100602 + N_100576__F_100580 => N_100576__F_100591 + N_100576__F_100580 => N_100576__F_100593 + N_100576__F_100580 => N_100576__F_100596 + N_100576__F_100580 => N_100576__F_100604 + N_100576__F_100580 => N_100576__F_100601 + N_100576__F_100581 => N_100576__F_100591 + N_100576__F_100581 => N_100576__F_100594 + N_100576__F_100581 => N_100576__F_100596 + N_100576__F_100581 => N_100576__F_100601 + N_100576__F_100581 => N_100576__F_100604 + N_100576__F_100582 => N_100576__F_100591 + N_100576__F_100582 => N_100576__F_100593 + N_100576__F_100582 => N_100576__F_100596 + N_100576__F_100582 => N_100576__F_100601 + N_100576__F_100582 => N_100576__F_100605 + N_100576__F_100583 => N_100576__F_100591 + N_100576__F_100583 => N_100576__F_100594 + N_100576__F_100583 => N_100576__F_100596 + N_100576__F_100583 => N_100576__F_100601 + N_100576__F_100583 => N_100576__F_100604 + N_100576__F_100584 => N_100576__F_100591 + N_100576__F_100584 => N_100576__F_100594 + N_100576__F_100584 => N_100576__F_100596 + N_100576__F_100584 => N_100576__F_100601 + N_100576__F_100584 => N_100576__F_100605 + N_100576__F_100585 => N_100576__F_100591 + N_100576__F_100585 => N_100576__F_100593 + N_100576__F_100585 => N_100576__F_100598 + N_100576__F_100585 => N_100576__F_100602 + N_100576__F_100585 => N_100576__F_100605 + N_100576__F_100586 => N_100576__F_100591 + N_100576__F_100586 => N_100576__F_100594 + N_100576__F_100586 => N_100576__F_100598 + N_100576__F_100586 => N_100576__F_100600 + N_100576__F_100586 => N_100576__F_100604 + N_100576__F_100587 => N_100576__F_100591 + N_100576__F_100587 => N_100576__F_100594 + N_100576__F_100587 => N_100576__F_100598 + N_100576__F_100587 => N_100576__F_100602 + N_100576__F_100587 => N_100576__F_100605 + N_100618__I_100629_i_F_100630 => "N_104536__I_104551_i_F_104549" + N_100618__I_100629_i_F_100633 => "N_104536__I_104566_i_F_104564" + N_100618__I_100629_i_F_100636 => "N_104536__I_104581_i_F_104579" + N_100618__I_100629_i_F_100639 => "N_104536__I_104596_i_F_104594" + N_100618__I_100629_i_F_100642 => "N_104536__I_104611_i_F_104609" + N_100618__I_100629_i_F_100645 => "N_104536__I_104626_i_F_104624" + N_100618__I_100677_i_F_100678 => "N_104536__I_104551_i_F_104549" + N_100618__I_100677_i_F_100681 => "N_104536__I_104566_i_F_104564" + N_100618__I_100677_i_F_100684 => "N_104536__I_104581_i_F_104579" + N_100618__I_100677_i_F_100687 => "N_104536__I_104596_i_F_104594" + N_100618__I_100677_i_F_100690 => "N_104536__I_104611_i_F_104609" + N_100618__I_100677_i_F_100693 => "N_104536__I_104626_i_F_104624" + N_100000__I_100877_i_F_100881 => N_100000__I_100877_i_F_100920 + N_100000__I_100877_i_F_100884 => N_100000__I_100877_i_F_100938 + N_100000__I_100877_i_F_100887 => N_100000__I_100877_i_F_100938 + N_100000__I_100877_i_F_100890 => N_100000__I_100877_i_F_100935 + !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100920) + !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100923) + !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100926) + !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100935) + !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100938) + !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100920) + !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100923) + !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100926) + !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100935) + !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100938) + N_100000__I_100877_i_F_100899 => N_100000__I_100877_i_F_100926 + N_100000__I_100877_i_F_100902 => N_100000__I_100877_i_F_100938 + N_100000__I_100877_i_F_100905 => N_100000__I_100877_i_F_100920 + !(N_100000__I_100877_i_F_100914 & N_100000__I_100877_i_F_100956) + !(N_100000__I_100877_i_F_100914 & N_100000__I_100877_i_F_100959) + N_100000__I_100877_i_F_100914 => N_100000__I_100877_i_F_100965 + !(N_100000__I_100877_i_F_100914 & N_104687__F_104698) + N_100000__I_100976_i_F_100980 => N_100000__I_100976_i_F_101019 + N_100000__I_100976_i_F_100983 => N_100000__I_100976_i_F_101037 + N_100000__I_100976_i_F_100986 => N_100000__I_100976_i_F_101037 + N_100000__I_100976_i_F_100989 => N_100000__I_100976_i_F_101034 + !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101019) + !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101022) + !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101025) + !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101034) + !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101037) + !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101019) + !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101022) + !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101025) + !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101034) + !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101037) + N_100000__I_100976_i_F_100998 => N_100000__I_100976_i_F_101025 + N_100000__I_100976_i_F_101001 => N_100000__I_100976_i_F_101037 + N_100000__I_100976_i_F_101004 => N_100000__I_100976_i_F_101019 + !(N_100000__I_100976_i_F_101013 & N_100000__I_100976_i_F_101055) + !(N_100000__I_100976_i_F_101013 & N_100000__I_100976_i_F_101058) + N_100000__I_100976_i_F_101013 => N_100000__I_100976_i_F_101064 + !(N_100000__I_100976_i_F_101013 & N_104687__F_104698) + N_100000__I_101075_i_F_101079 => N_100000__I_101075_i_F_101118 + N_100000__I_101075_i_F_101082 => N_100000__I_101075_i_F_101136 + N_100000__I_101075_i_F_101085 => N_100000__I_101075_i_F_101136 + N_100000__I_101075_i_F_101088 => N_100000__I_101075_i_F_101133 + !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101118) + !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101121) + !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101124) + !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101133) + !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101136) + !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101118) + !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101121) + !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101124) + !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101133) + !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101136) + N_100000__I_101075_i_F_101097 => N_100000__I_101075_i_F_101124 + N_100000__I_101075_i_F_101100 => N_100000__I_101075_i_F_101136 + N_100000__I_101075_i_F_101103 => N_100000__I_101075_i_F_101118 + !(N_100000__I_101075_i_F_101112 & N_100000__I_101075_i_F_101154) + !(N_100000__I_101075_i_F_101112 & N_100000__I_101075_i_F_101157) + N_100000__I_101075_i_F_101112 => N_100000__I_101075_i_F_101163 + !(N_100000__I_101075_i_F_101112 & N_104687__F_104698) + N_100000__I_101174_i_F_101178 => N_100000__I_101174_i_F_101217 + N_100000__I_101174_i_F_101181 => N_100000__I_101174_i_F_101235 + N_100000__I_101174_i_F_101184 => N_100000__I_101174_i_F_101235 + N_100000__I_101174_i_F_101187 => N_100000__I_101174_i_F_101232 + !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101217) + !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101220) + !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101223) + !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101232) + !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101235) + !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101217) + !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101220) + !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101223) + !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101232) + !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101235) + N_100000__I_101174_i_F_101196 => N_100000__I_101174_i_F_101223 + N_100000__I_101174_i_F_101199 => N_100000__I_101174_i_F_101235 + N_100000__I_101174_i_F_101202 => N_100000__I_101174_i_F_101217 + !(N_100000__I_101174_i_F_101211 & N_100000__I_101174_i_F_101253) + !(N_100000__I_101174_i_F_101211 & N_100000__I_101174_i_F_101256) + N_100000__I_101174_i_F_101211 => N_100000__I_101174_i_F_101262 + !(N_100000__I_101174_i_F_101211 & N_104687__F_104698) + N_100000__I_101285_i_F_101289 => N_100000__I_101285_i_F_101298 + N_100000__I_101285_i_F_101289 => N_100000__I_101285_i_F_101304 + N_100000__I_101285_i_F_101292 => N_100000__I_101285_i_F_101298 + N_100000__I_101285_i_F_101292 => N_100000__I_101285_i_F_101307 + N_100000__I_101285_i_F_101298 => N_100000__I_101285_i_F_101313 + N_100000__I_101405_i_F_101409 => N_100000__I_101405_i_F_101418 + N_100000__I_101405_i_F_101409 => N_100000__I_101405_i_F_101424 + N_100000__I_101405_i_F_101412 => N_100000__I_101405_i_F_101418 + N_100000__I_101405_i_F_101412 => N_100000__I_101405_i_F_101427 + N_100000__I_101405_i_F_101418 => N_100000__I_101405_i_F_101433 + N_100000__I_101525_i_F_101529 => N_100000__I_101525_i_F_101538 + N_100000__I_101525_i_F_101529 => N_100000__I_101525_i_F_101544 + N_100000__I_101525_i_F_101532 => N_100000__I_101525_i_F_101538 + N_100000__I_101525_i_F_101532 => N_100000__I_101525_i_F_101547 + N_100000__I_101525_i_F_101538 => N_100000__I_101525_i_F_101553 + N_100000__I_101645_i_F_101649 => N_100000__I_101645_i_F_101658 + N_100000__I_101645_i_F_101649 => N_100000__I_101645_i_F_101664 + N_100000__I_101645_i_F_101652 => N_100000__I_101645_i_F_101658 + N_100000__I_101645_i_F_101652 => N_100000__I_101645_i_F_101667 + N_100000__I_101645_i_F_101658 => N_100000__I_101645_i_F_101673 + N_101932__F_101949 => N_101932__F_101988 + N_101932__F_101949 => N_101932__F_101989 + N_101932__F_101950 => N_101932__F_101988 + N_101932__F_101950 => N_101932__F_101989 + N_101932__F_101951 => N_101932__F_101988 + N_101932__F_101951 => N_101932__F_101989 + !(N_102004__F_102012 & "N_102004__F_102013") + N_102004__F_102020 => "N_104357__F_104386" + !("N_104284__F_104297" & "N_104284__F_104311") + !(N_104357__F_104411 & N_104357__F_104400) + !(N_104357__F_104411 & "N_104357__F_104401") + !(N_104357__F_104411 & "N_104357__F_104521") + N_104357__F_104411 => N_104357__F_104457 + N_104357__F_104411 => N_104357__F_104461 + N_104357__F_104411 => N_104357__F_104472 + N_104357__F_104411 => N_104357__F_104478 + N_104357__F_104411 => N_104357__F_104517 + N_104357__F_104411 => N_104357__F_104520 + N_104357__F_104411 => N_104357__F_104484 + N_104357__F_104411 => N_104357__F_104488 + N_104357__F_104411 => N_104357__F_104490 + !(N_104357__F_104411 & "N_104357__F_104497") + !(N_104357__F_104412 & N_104357__F_104400) + !(N_104357__F_104412 & "N_104357__F_104401") + !(N_104357__F_104412 & "N_104357__F_104521") + !(N_104357__F_104412 & N_104357__F_104480) + N_104357__F_104412 => N_104357__F_104457 + N_104357__F_104412 => N_104357__F_104461 + N_104357__F_104412 => N_104357__F_104473 + N_104357__F_104412 => "N_104357__F_104479" + N_104357__F_104412 => N_104357__F_104484 + N_104357__F_104412 => N_104357__F_104488 + N_104357__F_104412 => N_104357__F_104490 + N_104357__F_104412 => N_104357__F_104517 + N_104357__F_104412 => N_104357__F_104519 + !(N_104357__F_104412 & "N_104357__F_104497") + !(N_104357__F_104413 & N_104357__F_104400) + !(N_104357__F_104413 & "N_104357__F_104401") + !(N_104357__F_104413 & "N_104357__F_104521") + !(N_104357__F_104413 & N_104357__F_104480) + N_104357__F_104413 => N_104357__F_104457 + N_104357__F_104413 => N_104357__F_104461 + N_104357__F_104413 => N_104357__F_104474 + N_104357__F_104413 => "N_104357__F_104479" + N_104357__F_104413 => N_104357__F_104484 + N_104357__F_104413 => N_104357__F_104488 + N_104357__F_104413 => N_104357__F_104491 + N_104357__F_104413 => N_104357__F_104517 + N_104357__F_104413 => N_104357__F_104519 + !(N_104357__F_104413 & "N_104357__F_104497") + !(N_104357__F_104414 & "N_104357__F_104401") + !(N_104357__F_104414 & "N_104357__F_104521") + !(N_104357__F_104414 & N_104357__F_104480) + N_104357__F_104414 => N_104357__F_104458 + N_104357__F_104414 => N_104357__F_104462 + N_104357__F_104414 => N_104357__F_104473 + N_104357__F_104414 => "N_104357__F_104479" + N_104357__F_104414 => N_104357__F_104485 + N_104357__F_104414 => N_104357__F_104487 + N_104357__F_104414 => N_104357__F_104490 + N_104357__F_104414 => N_104357__F_104516 + N_104357__F_104414 => N_104357__F_104519 + !(N_104357__F_104414 & "N_104357__F_104497") + !(N_104357__F_104415 & N_104357__F_104480) + !(N_104357__F_104415 & "N_104357__F_104401") + !(N_104357__F_104415 & "N_104357__F_104521") + N_104357__F_104415 => N_104357__F_104458 + N_104357__F_104415 => N_104357__F_104462 + N_104357__F_104415 => N_104357__F_104474 + N_104357__F_104415 => "N_104357__F_104479" + N_104357__F_104415 => N_104357__F_104485 + N_104357__F_104415 => N_104357__F_104487 + N_104357__F_104415 => N_104357__F_104491 + N_104357__F_104415 => N_104357__F_104516 + N_104357__F_104415 => N_104357__F_104519 + !(N_104357__F_104415 & "N_104357__F_104497") + !(N_104357__F_104416 & N_104357__F_104480) + !(N_104357__F_104416 & "N_104357__F_104401") + !(N_104357__F_104416 & "N_104357__F_104521") + N_104357__F_104416 => N_104357__F_104458 + N_104357__F_104416 => N_104357__F_104461 + N_104357__F_104416 => N_104357__F_104473 + N_104357__F_104416 => "N_104357__F_104479" + N_104357__F_104416 => N_104357__F_104484 + N_104357__F_104416 => N_104357__F_104487 + N_104357__F_104416 => N_104357__F_104490 + N_104357__F_104416 => N_104357__F_104516 + N_104357__F_104416 => N_104357__F_104519 + !(N_104357__F_104416 & "N_104357__F_104497") + !(N_104357__F_104417 & N_104357__F_104480) + !(N_104357__F_104417 & "N_104357__F_104401") + !(N_104357__F_104417 & "N_104357__F_104521") + N_104357__F_104417 => N_104357__F_104458 + N_104357__F_104417 => N_104357__F_104461 + N_104357__F_104417 => N_104357__F_104474 + N_104357__F_104417 => "N_104357__F_104479" + N_104357__F_104417 => N_104357__F_104484 + N_104357__F_104417 => N_104357__F_104487 + N_104357__F_104417 => N_104357__F_104491 + N_104357__F_104417 => N_104357__F_104516 + N_104357__F_104417 => N_104357__F_104519 + !(N_104357__F_104417 & "N_104357__F_104497") + !(N_104357__F_104418 & "N_104357__F_104521") + N_104357__F_104418 => N_104357__F_104458 + N_104357__F_104418 => N_104357__F_104462 + N_104357__F_104418 => "N_104357__F_104479" + N_104357__F_104418 => N_104357__F_104480 + N_104357__F_104418 => N_104357__F_104485 + N_104357__F_104418 => N_104357__F_104487 + N_104357__F_104418 => N_104357__F_104516 + N_104357__F_104418 => N_104357__F_104519 + N_104357__F_104418 => "N_104357__F_104401" + N_104357__F_104418 => N_104357__F_104490 + N_104357__F_104418 => N_104357__F_104473 + N_104357__F_104418 => N_104357__F_104498 + !(N_104357__F_104419 & "N_104357__F_104521") + N_104357__F_104419 => N_104357__F_104458 + N_104357__F_104419 => N_104357__F_104462 + N_104357__F_104419 => N_104357__F_104481 + N_104357__F_104419 => N_104357__F_104485 + N_104357__F_104419 => N_104357__F_104487 + N_104357__F_104419 => "N_104357__F_104401" + N_104357__F_104419 => N_104357__F_104516 + N_104357__F_104419 => N_104357__F_104519 + N_104357__F_104419 => N_104357__F_104475 + N_104357__F_104419 => N_104357__F_104490 + N_104357__F_104419 => N_104357__F_104498 + !(N_104357__F_104420 & "N_104357__F_104521") + N_104357__F_104420 => N_104357__F_104458 + N_104357__F_104420 => N_104357__F_104462 + N_104357__F_104420 => N_104357__F_104481 + N_104357__F_104420 => N_104357__F_104519 + N_104357__F_104420 => N_104357__F_104516 + N_104357__F_104420 => N_104357__F_104490 + N_104357__F_104420 => N_104357__F_104487 + N_104357__F_104420 => N_104357__F_104485 + N_104357__F_104420 => "N_104357__F_104401" + N_104357__F_104420 => N_104357__F_104475 + N_104357__F_104420 => N_104357__F_104499 + !(N_104357__F_104421 & N_104357__F_104480) + !(N_104357__F_104421 & "N_104357__F_104401") + N_104357__F_104421 => N_104357__F_104458 + N_104357__F_104421 => N_104357__F_104462 + N_104357__F_104421 => N_104357__F_104473 + N_104357__F_104421 => "N_104357__F_104479" + N_104357__F_104421 => N_104357__F_104485 + N_104357__F_104421 => N_104357__F_104487 + N_104357__F_104421 => N_104357__F_104490 + N_104357__F_104421 => N_104357__F_104516 + N_104357__F_104421 => N_104357__F_104519 + N_104357__F_104421 => "N_104357__F_104521" + !(N_104357__F_104421 & "N_104357__F_104497") + !(N_104357__F_104422 & N_104357__F_104480) + !(N_104357__F_104422 & "N_104357__F_104401") + N_104357__F_104422 => N_104357__F_104458 + N_104357__F_104422 => N_104357__F_104462 + N_104357__F_104422 => N_104357__F_104474 + N_104357__F_104422 => "N_104357__F_104479" + N_104357__F_104422 => N_104357__F_104485 + N_104357__F_104422 => N_104357__F_104487 + N_104357__F_104422 => N_104357__F_104491 + N_104357__F_104422 => N_104357__F_104516 + N_104357__F_104422 => N_104357__F_104519 + N_104357__F_104422 => "N_104357__F_104521" + !(N_104357__F_104422 & "N_104357__F_104497") + !(N_104357__F_104423 & N_104357__F_104480) + !(N_104357__F_104423 & "N_104357__F_104401") + N_104357__F_104423 => N_104357__F_104458 + N_104357__F_104423 => N_104357__F_104462 + N_104357__F_104423 => N_104357__F_104474 + N_104357__F_104423 => "N_104357__F_104479" + N_104357__F_104423 => N_104357__F_104485 + N_104357__F_104423 => N_104357__F_104487 + N_104357__F_104423 => N_104357__F_104491 + N_104357__F_104423 => N_104357__F_104516 + N_104357__F_104423 => N_104357__F_104519 + N_104357__F_104423 => "N_104357__F_104521" + !(N_104357__F_104423 & "N_104357__F_104497") + N_104357__F_104424 => N_104357__F_104458 + N_104357__F_104424 => N_104357__F_104462 + N_104357__F_104424 => "N_104357__F_104479" + N_104357__F_104424 => N_104357__F_104480 + N_104357__F_104424 => N_104357__F_104485 + N_104357__F_104424 => N_104357__F_104487 + N_104357__F_104424 => N_104357__F_104490 + N_104357__F_104424 => "N_104357__F_104401" + N_104357__F_104424 => N_104357__F_104516 + N_104357__F_104424 => N_104357__F_104519 + N_104357__F_104424 => "N_104357__F_104521" + N_104357__F_104424 => N_104357__F_104473 + N_104357__F_104424 => N_104357__F_104498 + N_104357__F_104425 => N_104357__F_104458 + N_104357__F_104425 => N_104357__F_104462 + N_104357__F_104425 => N_104357__F_104481 + N_104357__F_104425 => N_104357__F_104485 + N_104357__F_104425 => N_104357__F_104487 + N_104357__F_104425 => "N_104357__F_104401" + N_104357__F_104425 => N_104357__F_104516 + N_104357__F_104425 => N_104357__F_104519 + N_104357__F_104425 => "N_104357__F_104521" + N_104357__F_104425 => N_104357__F_104490 + N_104357__F_104425 => N_104357__F_104475 + N_104357__F_104425 => N_104357__F_104498 + N_104357__F_104426 => N_104357__F_104458 + N_104357__F_104426 => N_104357__F_104462 + N_104357__F_104426 => N_104357__F_104481 + N_104357__F_104426 => N_104357__F_104485 + N_104357__F_104426 => N_104357__F_104487 + N_104357__F_104426 => "N_104357__F_104401" + N_104357__F_104426 => N_104357__F_104516 + N_104357__F_104426 => N_104357__F_104519 + N_104357__F_104426 => "N_104357__F_104521" + N_104357__F_104426 => N_104357__F_104490 + N_104357__F_104426 => N_104357__F_104475 + N_104357__F_104426 => N_104357__F_104499 + N_104357__F_104428 => N_104357__F_104464 + !(N_104357__F_104428 & "N_104357__F_104467") + N_104357__F_104429 => N_104357__F_104465 + !(N_104357__F_104429 & "N_104357__F_104467") + N_104357__F_104430 => N_104357__F_104464 + N_104357__F_104430 => N_104357__F_104469 + N_104357__F_104431 => N_104357__F_104469 + N_104357__F_104431 => N_104357__F_104465 + !(N_104357__F_104432 & "N_104357__F_104467") + N_104357__F_104432 => N_104357__F_104466 + N_104357__F_104434 => N_104357__F_104500 + N_104357__F_104434 => N_104357__F_104495 + !(N_104357__F_104434 & "N_104357__F_104521") + !(N_104357__F_104434 & N_104357__F_104403) + !(N_104357__F_104434 & N_104357__F_104406) + !(N_104357__F_104434 & N_104357__F_104407) + N_104357__F_104435 => N_104357__F_104494 + N_104357__F_104435 => N_104357__F_104500 + !(N_104357__F_104435 & "N_104357__F_104521") + !(N_104357__F_104435 & N_104357__F_104403) + !(N_104357__F_104435 & N_104357__F_104407) + N_104357__F_104436 => N_104357__F_104494 + N_104357__F_104436 => N_104357__F_104500 + N_104357__F_104436 => "N_104357__F_104521" + !(N_104357__F_104436 & N_104357__F_104522) + !(N_104357__F_104436 & N_104357__F_104403) + !(N_104357__F_104436 & N_104357__F_104407) + N_104357__F_104437 => N_104357__F_104494 + N_104357__F_104437 => N_104357__F_104500 + N_104357__F_104437 => "N_104357__F_104521" + N_104357__F_104437 => N_104357__F_104522 + !(N_104357__F_104437 & N_104357__F_104403) + !(N_104357__F_104437 & N_104357__F_104407) + N_104357__F_104438 => N_104357__F_104494 + N_104357__F_104438 => "N_104357__F_104501" + !(N_104357__F_104438 & "N_104357__F_104521") + N_104357__F_104439 => N_104357__F_104494 + N_104357__F_104439 => "N_104357__F_104501" + N_104357__F_104439 => "N_104357__F_104521" + !(N_104357__F_104439 & N_104357__F_104522) + N_104357__F_104440 => N_104357__F_104494 + N_104357__F_104440 => "N_104357__F_104501" + N_104357__F_104440 => "N_104357__F_104521" + N_104357__F_104440 => N_104357__F_104522 + !(N_104357__F_104442 & "N_104357__F_104504") + !(N_104357__F_104442 & N_104357__F_104502) + !(N_104357__F_104442 & N_104357__F_104407) + N_104357__F_104443 => "N_104357__F_104504" + !(N_104357__F_104443 & N_104357__F_104502) + N_104357__F_104444 => N_104357__F_104502 + !(N_104357__F_104444 & "N_104357__F_104504") + !(N_104357__F_104445 & N_104357__F_104502) + N_104357__F_104445 => N_104357__F_104405 + N_104357__F_104445 => N_104357__F_104505 + !(N_104357__F_104447 & N_104357__F_104523) + N_104357__F_104448 => N_104357__F_104523 + N_104357__F_104449 => N_104357__F_104523 + !(N_104357__F_104451 & "N_104357__F_104506") + N_104357__F_104452 => N_104357__F_104507 + N_104357__F_104453 => N_104357__F_104508 + N_104357__F_104454 => N_104357__F_104405 + N_104357__F_104454 => N_104357__F_104509 + N_104357__F_104457 => N_104357__F_104488 + N_104357__F_104458 => N_104357__F_104487 + N_104357__F_104522 => N_104357__F_104502 + "N_104536__I_104581_i_F_104582" => N_104536__I_104581_i_F_104585 + !("N_104536__I_104581_i_F_104582" & N_104536__I_104581_i_F_104588) + "N_104536__I_104626_i_F_104627" => N_104536__I_104626_i_F_104630 + !("N_104536__I_104626_i_F_104627" & N_104536__I_104626_i_F_104633) + N_104700__F_104703 => N_104357__F_104511 + N_104700__F_104704 => N_104357__F_104511 + N_104700__F_104705 => N_104357__F_104512 + N_104700__F_104709 => N_104357__F_104512 + N_104700__F_104710 => N_104357__F_104511 + N_104700__F_104711 => N_104357__F_104511 + N_104700__F_104713 => N_104357__F_104513 + N_104700__F_104714 => N_104357__F_104513 + N_104700__F_104715 => N_104357__F_104513 + N_104700__F_104716 => N_104357__F_104511 + N_104700__F_104717 => N_104357__F_104511 + N_104700__F_104723 => N_104357__F_104511 + N_104700__F_104726 => N_104357__F_104511 + N_100000__I_100877_i_F_100920 => N_100000__I_100877_i_F_100971 + !(N_100000__I_100877_i_F_100920 & N_100000__I_100877_i_F_100956) + !(N_100000__I_100877_i_F_100920 & N_100000__I_100877_i_F_100959) + N_100000__I_100877_i_F_100923 => N_100000__I_100877_i_F_100968 + !(N_100000__I_100877_i_F_100923 & N_100000__I_100877_i_F_100956) + !(N_100000__I_100877_i_F_100923 & N_100000__I_100877_i_F_100959) + N_100000__I_100877_i_F_100926 => N_100000__I_100877_i_F_100968 + N_100000__I_100877_i_F_100926 => N_100000__I_100877_i_F_100956 + N_100000__I_100877_i_F_100926 => N_100000__I_100877_i_F_100959 + N_100000__I_100877_i_F_100929 => N_100000__I_100877_i_F_100965 + !(N_100000__I_100877_i_F_100929 & N_100000__I_100877_i_F_100956) + !(N_100000__I_100877_i_F_100929 & N_100000__I_100877_i_F_100959) + N_100000__I_100877_i_F_100932 => N_100000__I_100877_i_F_100965 + !(N_100000__I_100877_i_F_100932 & N_100000__I_100877_i_F_100956) + !(N_100000__I_100877_i_F_100932 & N_100000__I_100877_i_F_100959) + N_100000__I_100877_i_F_100935 => N_100000__I_100877_i_F_100965 + N_100000__I_100877_i_F_100935 => N_100000__I_100877_i_F_100956 + !(N_100000__I_100877_i_F_100935 & N_100000__I_100877_i_F_100959) + N_100000__I_100877_i_F_100938 => N_100000__I_100877_i_F_100971 + N_100000__I_100877_i_F_100938 => N_100000__I_100877_i_F_100956 + N_100000__I_100877_i_F_100938 => N_100000__I_100877_i_F_100959 + N_100000__I_100877_i_F_100941 => N_100000__I_100877_i_F_100965 + !(N_100000__I_100877_i_F_100941 & N_100000__I_100877_i_F_100956) + !(N_100000__I_100877_i_F_100941 & N_100000__I_100877_i_F_100959) + N_100000__I_100976_i_F_101019 => N_100000__I_100976_i_F_101070 + !(N_100000__I_100976_i_F_101019 & N_100000__I_100976_i_F_101055) + !(N_100000__I_100976_i_F_101019 & N_100000__I_100976_i_F_101058) + N_100000__I_100976_i_F_101022 => N_100000__I_100976_i_F_101067 + !(N_100000__I_100976_i_F_101022 & N_100000__I_100976_i_F_101055) + !(N_100000__I_100976_i_F_101022 & N_100000__I_100976_i_F_101058) + N_100000__I_100976_i_F_101025 => N_100000__I_100976_i_F_101067 + N_100000__I_100976_i_F_101025 => N_100000__I_100976_i_F_101055 + N_100000__I_100976_i_F_101025 => N_100000__I_100976_i_F_101058 + N_100000__I_100976_i_F_101028 => N_100000__I_100976_i_F_101064 + !(N_100000__I_100976_i_F_101028 & N_100000__I_100976_i_F_101055) + !(N_100000__I_100976_i_F_101028 & N_100000__I_100976_i_F_101058) + N_100000__I_100976_i_F_101031 => N_100000__I_100976_i_F_101064 + !(N_100000__I_100976_i_F_101031 & N_100000__I_100976_i_F_101055) + !(N_100000__I_100976_i_F_101031 & N_100000__I_100976_i_F_101058) + N_100000__I_100976_i_F_101034 => N_100000__I_100976_i_F_101064 + N_100000__I_100976_i_F_101034 => N_100000__I_100976_i_F_101055 + !(N_100000__I_100976_i_F_101034 & N_100000__I_100976_i_F_101058) + N_100000__I_100976_i_F_101037 => N_100000__I_100976_i_F_101070 + N_100000__I_100976_i_F_101037 => N_100000__I_100976_i_F_101055 + N_100000__I_100976_i_F_101037 => N_100000__I_100976_i_F_101058 + N_100000__I_100976_i_F_101040 => N_100000__I_100976_i_F_101064 + !(N_100000__I_100976_i_F_101040 & N_100000__I_100976_i_F_101055) + !(N_100000__I_100976_i_F_101040 & N_100000__I_100976_i_F_101058) + N_100000__I_101075_i_F_101118 => N_100000__I_101075_i_F_101169 + !(N_100000__I_101075_i_F_101118 & N_100000__I_101075_i_F_101154) + !(N_100000__I_101075_i_F_101118 & N_100000__I_101075_i_F_101157) + N_100000__I_101075_i_F_101121 => N_100000__I_101075_i_F_101166 + !(N_100000__I_101075_i_F_101121 & N_100000__I_101075_i_F_101154) + !(N_100000__I_101075_i_F_101121 & N_100000__I_101075_i_F_101157) + N_100000__I_101075_i_F_101124 => N_100000__I_101075_i_F_101166 + N_100000__I_101075_i_F_101124 => N_100000__I_101075_i_F_101154 + N_100000__I_101075_i_F_101124 => N_100000__I_101075_i_F_101157 + N_100000__I_101075_i_F_101127 => N_100000__I_101075_i_F_101163 + !(N_100000__I_101075_i_F_101127 & N_100000__I_101075_i_F_101154) + !(N_100000__I_101075_i_F_101127 & N_100000__I_101075_i_F_101157) + N_100000__I_101075_i_F_101130 => N_100000__I_101075_i_F_101163 + !(N_100000__I_101075_i_F_101130 & N_100000__I_101075_i_F_101154) + !(N_100000__I_101075_i_F_101130 & N_100000__I_101075_i_F_101157) + N_100000__I_101075_i_F_101133 => N_100000__I_101075_i_F_101163 + N_100000__I_101075_i_F_101133 => N_100000__I_101075_i_F_101154 + !(N_100000__I_101075_i_F_101133 & N_100000__I_101075_i_F_101157) + N_100000__I_101075_i_F_101136 => N_100000__I_101075_i_F_101169 + N_100000__I_101075_i_F_101136 => N_100000__I_101075_i_F_101154 + N_100000__I_101075_i_F_101136 => N_100000__I_101075_i_F_101157 + N_100000__I_101075_i_F_101139 => N_100000__I_101075_i_F_101163 + !(N_100000__I_101075_i_F_101139 & N_100000__I_101075_i_F_101154) + !(N_100000__I_101075_i_F_101139 & N_100000__I_101075_i_F_101157) + N_100000__I_101174_i_F_101217 => N_100000__I_101174_i_F_101268 + !(N_100000__I_101174_i_F_101217 & N_100000__I_101174_i_F_101253) + !(N_100000__I_101174_i_F_101217 & N_100000__I_101174_i_F_101256) + N_100000__I_101174_i_F_101220 => N_100000__I_101174_i_F_101265 + !(N_100000__I_101174_i_F_101220 & N_100000__I_101174_i_F_101253) + !(N_100000__I_101174_i_F_101220 & N_100000__I_101174_i_F_101256) + N_100000__I_101174_i_F_101223 => N_100000__I_101174_i_F_101265 + N_100000__I_101174_i_F_101223 => N_100000__I_101174_i_F_101253 + N_100000__I_101174_i_F_101223 => N_100000__I_101174_i_F_101256 + N_100000__I_101174_i_F_101226 => N_100000__I_101174_i_F_101262 + !(N_100000__I_101174_i_F_101226 & N_100000__I_101174_i_F_101253) + !(N_100000__I_101174_i_F_101226 & N_100000__I_101174_i_F_101256) + N_100000__I_101174_i_F_101229 => N_100000__I_101174_i_F_101262 + !(N_100000__I_101174_i_F_101229 & N_100000__I_101174_i_F_101253) + !(N_100000__I_101174_i_F_101229 & N_100000__I_101174_i_F_101256) + N_100000__I_101174_i_F_101232 => N_100000__I_101174_i_F_101262 + N_100000__I_101174_i_F_101232 => N_100000__I_101174_i_F_101253 + !(N_100000__I_101174_i_F_101232 & N_100000__I_101174_i_F_101256) + N_100000__I_101174_i_F_101235 => N_100000__I_101174_i_F_101268 + N_100000__I_101174_i_F_101235 => N_100000__I_101174_i_F_101253 + N_100000__I_101174_i_F_101235 => N_100000__I_101174_i_F_101256 + N_100000__I_101174_i_F_101238 => N_100000__I_101174_i_F_101262 + !(N_100000__I_101174_i_F_101238 & N_100000__I_101174_i_F_101253) + !(N_100000__I_101174_i_F_101238 & N_100000__I_101174_i_F_101256) + N_100000__I_101285_i_F_101322 => "N_100000__I_101285_i_F_101334" + N_100000__I_101285_i_F_101325 => "N_100000__I_101285_i_F_101343" + N_100000__I_101285_i_F_101328 => "N_100000__I_101285_i_F_101343" + N_100000__I_101285_i_F_101331 => N_100000__I_101285_i_F_101358 + N_100000__I_101285_i_F_101358 => N_100000__I_101285_i_F_101385 + N_100000__I_101405_i_F_101442 => "N_100000__I_101405_i_F_101454" + N_100000__I_101405_i_F_101445 => "N_100000__I_101405_i_F_101463" + N_100000__I_101405_i_F_101448 => "N_100000__I_101405_i_F_101463" + N_100000__I_101405_i_F_101451 => N_100000__I_101405_i_F_101478 + N_100000__I_101405_i_F_101478 => N_100000__I_101405_i_F_101505 + N_100000__I_101525_i_F_101562 => "N_100000__I_101525_i_F_101574" + N_100000__I_101525_i_F_101565 => "N_100000__I_101525_i_F_101583" + N_100000__I_101525_i_F_101568 => "N_100000__I_101525_i_F_101583" + N_100000__I_101525_i_F_101571 => N_100000__I_101525_i_F_101598 + N_100000__I_101525_i_F_101598 => N_100000__I_101525_i_F_101625 + N_100000__I_101645_i_F_101682 => "N_100000__I_101645_i_F_101694" + N_100000__I_101645_i_F_101685 => "N_100000__I_101645_i_F_101703" + N_100000__I_101645_i_F_101688 => "N_100000__I_101645_i_F_101703" + N_100000__I_101645_i_F_101691 => N_100000__I_101645_i_F_101718 + N_100000__I_101645_i_F_101718 => N_100000__I_101645_i_F_101745 + !(N_102385__F_102488 & N_102385__F_102457) + !(N_102385__F_102488 & N_102385__F_102458) + !(N_102385__F_102488 & N_102385__F_102459) + N_102383__F_102779 => N_102383__F_102782 + N_102383__F_102779 => N_102383__F_102783 + N_102383__F_102779 => N_102383__F_102784 + N_102383__F_102779 => N_102383__F_102785 + N_102383__F_102779 => N_102383__F_102786 + N_102383__F_102779 => N_102383__F_102787 + N_102383__F_102790 => N_102383__I_103300_i_F_103304 + N_102383__F_102790 => N_102383__I_103546_i_F_103550 + N_102383__F_102790 => N_102383__I_103792_i_F_103796 + N_102383__F_102790 => N_102383__I_104038_i_F_104042 + N_102383__F_102790 => N_102383__I_102808_i_F_103010 + N_102383__F_102790 => N_102383__I_103054_i_F_103256 + N_102383__F_102790 => N_104687__F_104692 + N_102383__F_102790 => N_104687__F_104695 + N_102383__F_102791 => N_102383__I_103300_i_F_103307 + N_102383__F_102791 => N_102383__I_103546_i_F_103553 + N_102383__F_102791 => N_102383__I_103792_i_F_103799 + N_102383__F_102791 => N_102383__I_104038_i_F_104045 + N_102383__F_102791 => N_102383__I_102808_i_F_103016 + N_102383__F_102791 => N_102383__I_103054_i_F_103262 + N_102383__F_102792 => N_102383__I_103300_i_F_103310 + N_102383__F_102792 => N_102383__I_103546_i_F_103556 + N_102383__F_102792 => N_102383__I_103792_i_F_103802 + N_102383__F_102792 => N_102383__I_104038_i_F_104048 + N_102383__F_102792 => N_102383__I_102808_i_F_103019 + N_102383__F_102792 => N_102383__I_103054_i_F_103265 + N_102383__F_102793 => N_102383__I_102808_i_F_103022 + N_102383__F_102793 => N_102383__I_103054_i_F_103268 + N_102383__F_102793 => N_102383__I_103300_i_F_103316 + N_102383__F_102793 => N_102383__I_103546_i_F_103562 + N_102383__F_102793 => N_102383__I_104038_i_F_104054 + N_102383__F_102793 => N_102383__I_103792_i_F_103808 + N_102383__F_102794 => N_102383__I_102808_i_F_103025 + N_102383__F_102794 => N_102383__I_103054_i_F_103271 + N_102383__F_102794 => N_102383__I_103300_i_F_103319 + N_102383__F_102794 => N_102383__I_103546_i_F_103565 + N_102383__F_102794 => N_102383__I_104038_i_F_104057 + N_102383__F_102794 => N_102383__I_103792_i_F_103811 + N_102383__F_102796 => N_102383__I_102808_i_F_103028 + N_102383__F_102796 => N_102383__I_103054_i_F_103274 + N_102383__F_102796 => N_102383__I_103300_i_F_103322 + N_102383__F_102796 => N_102383__I_103546_i_F_103568 + N_102383__F_102796 => N_102383__I_103792_i_F_103814 + N_102383__F_102796 => N_102383__I_104038_i_F_104060 + N_102383__F_102797 => N_102383__I_103300_i_F_103325 + N_102383__F_102797 => N_102383__I_103546_i_F_103571 + N_102383__F_102797 => N_102383__I_103792_i_F_103817 + N_102383__F_102797 => N_102383__I_104038_i_F_104063 + N_102383__F_102798 => N_102383__I_102808_i_F_103013 + N_102383__F_102798 => N_102383__I_103054_i_F_103259 + N_102383__F_102798 => N_102383__I_103300_i_F_103304 + N_102383__F_102798 => N_102383__I_103546_i_F_103550 + N_102383__F_102798 => N_102383__I_103792_i_F_103796 + N_102383__F_102798 => N_102383__I_104038_i_F_104042 + N_102383__F_102798 => N_104687__F_104693 + N_102383__F_102798 => N_104687__F_104696 + N_102383__F_102799 => N_102383__I_102808_i_F_103031 + N_102383__F_102799 => N_102383__I_103054_i_F_103277 + N_102383__F_102799 => N_102383__I_103300_i_F_103313 + N_102383__F_102799 => N_102383__I_103546_i_F_103559 + N_102383__F_102799 => N_102383__I_103792_i_F_103805 + N_102383__F_102799 => N_102383__I_104038_i_F_104051 + N_102383__F_102800 => N_102383__I_103300_i_F_103331 + N_102383__F_102800 => N_102383__I_103546_i_F_103577 + N_102383__F_102800 => N_102383__I_103792_i_F_103823 + N_102383__F_102800 => N_102383__I_104038_i_F_104069 + N_102383__F_102800 => N_104687__F_104699 + N_102383__F_102801 => N_102383__I_103300_i_F_103328 + N_102383__F_102801 => N_102383__I_103546_i_F_103574 + N_102383__F_102801 => N_102383__I_103792_i_F_103820 + N_102383__F_102801 => N_102383__I_104038_i_F_104066 + N_102383__F_102801 => "N_104687__F_104694" + N_102383__F_102801 => "N_104687__F_104691" + N_102383__F_102802 => N_102383__I_103300_i_F_103334 + N_102383__F_102802 => N_102383__I_103546_i_F_103580 + N_102383__F_102802 => N_102383__I_103792_i_F_103826 + N_102383__F_102802 => N_102383__I_104038_i_F_104072 + N_102383__F_102802 => N_104687__F_104692 + N_102383__F_102802 => N_104687__F_104695 + N_102383__F_102803 => N_102383__I_103300_i_F_103337 + N_102383__F_102803 => N_102383__I_103546_i_F_103583 + N_102383__F_102803 => N_102383__I_103792_i_F_103829 + N_102383__F_102803 => N_102383__I_104038_i_F_104075 + N_102383__F_102803 => N_104687__F_104692 + N_102383__F_102803 => N_104687__F_104695 + N_102383__F_102804 => N_102383__I_103300_i_F_103340 + N_102383__F_102804 => N_102383__I_103546_i_F_103586 + N_102383__F_102804 => N_102383__I_103792_i_F_103832 + N_102383__F_102804 => N_102383__I_104038_i_F_104078 + N_102383__F_102804 => N_104687__F_104692 + N_102383__F_102804 => N_104687__F_104695 + N_102383__F_102805 => N_102383__I_103300_i_F_103343 + N_102383__F_102805 => N_102383__I_103546_i_F_103589 + N_102383__F_102805 => N_102383__I_103792_i_F_103835 + N_102383__F_102805 => N_102383__I_104038_i_F_104081 + N_102383__F_102805 => N_100000__F_101275 + N_102383__F_102805 => N_100000__F_101276 + !("N_104284__F_104291" & "N_104284__F_104297") + !(N_104284__F_104309 & N_104284__F_104332) + N_104284__F_104310 => N_104284__F_104332 + !(N_104284__F_104327 & N_104284__F_104332) + N_104284__F_104328 => N_104284__F_104332 + N_104357__F_104461 => N_104357__F_104484 + N_104357__F_104462 => N_104357__F_104485 + N_104357__F_104472 => N_104357__F_104490 + N_104357__F_104473 => N_104357__F_104490 + N_104357__F_104474 => N_104357__F_104491 + !(N_104357__F_104499 & N_104357__F_104402) + N_104357__F_104505 => N_104357__F_104405 + N_104357__F_104509 => N_104357__F_104405 + N_104357__F_104516 => N_104357__F_104487 + N_104357__F_104517 => N_104357__F_104488 + !(N_104536__I_104551_i_F_104555 & N_104536__I_104566_i_F_104570) + N_104536__I_104551_i_F_104555 => N_104649__F_104771 + !(N_104536__I_104566_i_F_104570 & N_104536__I_104551_i_F_104555) + N_104536__I_104566_i_F_104570 => N_104649__F_104785 + N_104536__I_104596_i_F_104600 => N_104649__F_104771 + N_104536__I_104611_i_F_104615 => N_104649__F_104785 + N_100000__I_101285_i_F_101337 => N_100000__I_101285_i_F_101379 + N_100000__I_101285_i_F_101340 => N_100000__I_101285_i_F_101382 + N_100000__I_101285_i_F_101346 => N_100000__I_101285_i_F_101364 + N_100000__I_101285_i_F_101349 => N_100000__I_101285_i_F_101367 + N_100000__I_101285_i_F_101352 => N_100000__I_101285_i_F_101373 + N_100000__I_101285_i_F_101355 => N_100000__I_101285_i_F_101370 + N_100000__I_101405_i_F_101457 => N_100000__I_101405_i_F_101499 + N_100000__I_101405_i_F_101460 => N_100000__I_101405_i_F_101502 + N_100000__I_101405_i_F_101466 => N_100000__I_101405_i_F_101484 + N_100000__I_101405_i_F_101469 => N_100000__I_101405_i_F_101487 + N_100000__I_101405_i_F_101472 => N_100000__I_101405_i_F_101493 + N_100000__I_101405_i_F_101475 => N_100000__I_101405_i_F_101490 + N_100000__I_101525_i_F_101577 => N_100000__I_101525_i_F_101619 + N_100000__I_101525_i_F_101580 => N_100000__I_101525_i_F_101622 + N_100000__I_101525_i_F_101586 => N_100000__I_101525_i_F_101604 + N_100000__I_101525_i_F_101589 => N_100000__I_101525_i_F_101607 + N_100000__I_101525_i_F_101592 => N_100000__I_101525_i_F_101613 + N_100000__I_101525_i_F_101595 => N_100000__I_101525_i_F_101610 + N_100000__I_101645_i_F_101697 => N_100000__I_101645_i_F_101739 + N_100000__I_101645_i_F_101700 => N_100000__I_101645_i_F_101742 + N_100000__I_101645_i_F_101706 => N_100000__I_101645_i_F_101724 + N_100000__I_101645_i_F_101709 => N_100000__I_101645_i_F_101727 + N_100000__I_101645_i_F_101712 => N_100000__I_101645_i_F_101733 + N_100000__I_101645_i_F_101715 => N_100000__I_101645_i_F_101730 + N_102385__F_102388 => N_102385__F_102428 + N_102385__F_102388 => N_102385__F_102434 + N_102385__F_102388 => N_102385__F_102439 + N_102385__F_102388 => N_102385__F_102444 + N_102385__F_102388 => N_102385__F_102408 + N_102385__F_102388 => N_102385__F_102457 + N_102385__F_102388 => N_102385__F_102487 + N_102385__F_102388 => N_102385__F_102466 + N_102385__F_102388 => N_102385__F_102491 + N_102385__F_102388 => N_102385__F_102474 + N_102385__F_102388 => N_102385__F_102453 + N_102385__F_102388 => N_102385__F_102448 + N_102385__F_102388 => N_102385__F_102476 + N_102385__F_102388 => N_102385__F_102482 + N_102385__F_102389 => N_102385__F_102430 + N_102385__F_102389 => N_102385__F_102434 + N_102385__F_102389 => N_102385__F_102439 + N_102385__F_102389 => N_102385__F_102444 + N_102385__F_102389 => N_102385__F_102409 + N_102385__F_102389 => N_102385__F_102453 + N_102385__F_102389 => N_102385__F_102457 + N_102385__F_102389 => N_102385__F_102467 + N_102385__F_102389 => N_102385__F_102474 + N_102385__F_102389 => N_102385__F_102476 + N_102385__F_102389 => N_102385__F_102482 + N_102385__F_102389 => N_102385__F_102487 + N_102385__F_102389 => N_102385__F_102448 + N_102385__F_102389 => N_102385__F_102491 + N_102385__F_102390 => N_102385__F_102410 + N_102385__F_102390 => N_102385__F_102428 + N_102385__F_102390 => N_102385__F_102434 + N_102385__F_102390 => N_102385__F_102439 + N_102385__F_102390 => N_102385__F_102444 + N_102385__F_102390 => N_102385__F_102447 + N_102385__F_102390 => N_102385__F_102453 + N_102385__F_102390 => N_102385__F_102458 + N_102385__F_102390 => N_102385__F_102466 + N_102385__F_102390 => N_102385__F_102474 + N_102385__F_102390 => N_102385__F_102481 + N_102385__F_102390 => N_102385__F_102491 + !(N_102385__F_102390 & N_102385__F_102420) + !(N_102385__F_102390 & N_102385__F_102487) + !(N_102385__F_102390 & N_102385__F_102488) + !(N_102385__F_102390 & N_102385__F_102500) + N_102385__F_102391 => N_102385__F_102487 + N_102385__F_102391 => N_102385__F_102413 + N_102385__F_102391 => N_102385__F_102429 + N_102385__F_102391 => N_102385__F_102436 + N_102385__F_102391 => N_102385__F_102441 + N_102385__F_102391 => N_102385__F_102444 + !(N_102385__F_102391 & N_102385__F_102451) + N_102385__F_102391 => N_102385__F_102458 + N_102385__F_102391 => N_102385__F_102467 + N_102385__F_102391 => N_102385__F_102470 + N_102385__F_102391 => N_102385__F_102477 + N_102385__F_102391 => N_102385__F_102481 + N_102385__F_102391 => N_102385__F_102492 + N_102385__F_102392 => N_102385__F_102413 + !(N_102385__F_102392 & N_102385__F_102420) + N_102385__F_102392 => N_102385__F_102429 + N_102385__F_102392 => N_102385__F_102436 + N_102385__F_102392 => N_102385__F_102441 + N_102385__F_102392 => N_102385__F_102444 + N_102385__F_102392 => N_102385__F_102451 + N_102385__F_102392 => N_102385__F_102459 + N_102385__F_102392 => N_102385__F_102468 + N_102385__F_102392 => N_102385__F_102471 + N_102385__F_102392 => N_102385__F_102477 + N_102385__F_102392 => N_102385__F_102481 + N_102385__F_102392 => N_102385__F_102487 + N_102385__F_102392 => N_102385__F_102493 + N_102385__F_102393 => N_102385__F_102414 + N_102385__F_102393 => N_102385__F_102429 + N_102385__F_102393 => N_102385__F_102436 + N_102385__F_102393 => N_102385__F_102441 + N_102385__F_102393 => N_102385__F_102444 + !(N_102385__F_102393 & N_102385__F_102451) + !(N_102385__F_102393 & N_102385__F_102447) + N_102385__F_102393 => N_102385__F_102454 + N_102385__F_102393 => N_102385__F_102457 + N_102385__F_102393 => N_102385__F_102467 + N_102385__F_102393 => N_102385__F_102474 + N_102385__F_102393 => N_102385__F_102477 + N_102385__F_102393 => N_102385__F_102481 + N_102385__F_102393 => N_102385__F_102487 + N_102385__F_102393 => N_102385__F_102492 + N_102385__F_102394 => N_102385__F_102496 + N_102385__F_102394 => N_102385__F_102414 + !(N_102385__F_102394 & N_102385__F_102420) + N_102385__F_102394 => N_102385__F_102429 + N_102385__F_102394 => N_102385__F_102436 + N_102385__F_102394 => N_102385__F_102441 + N_102385__F_102394 => N_102385__F_102444 + N_102385__F_102394 => N_102385__F_102460 + N_102385__F_102394 => N_102385__F_102468 + N_102385__F_102394 => N_102385__F_102472 + N_102385__F_102394 => N_102385__F_102477 + N_102385__F_102394 => N_102385__F_102481 + N_102385__F_102394 => N_102385__F_102487 + N_102385__F_102394 => N_102385__F_102496 + N_102385__F_102394 => N_102385__F_102454 + !(N_102385__F_102394 & N_102385__F_102447) + !(N_102385__F_102394 & N_102385__F_102451) + N_102385__F_102394 => N_102385__F_102488 + N_102385__F_102394 => N_104687__F_104692 + N_102385__F_102394 => N_104687__F_104695 + N_102385__F_102395 => N_102385__F_102416 + N_102385__F_102395 => N_102385__F_102431 + N_102385__F_102395 => N_102385__F_102436 + N_102385__F_102395 => N_102385__F_102441 + N_102385__F_102395 => N_102385__F_102444 + !(N_102385__F_102395 & N_102385__F_102451) + N_102385__F_102395 => N_102385__F_102457 + N_102385__F_102395 => N_102385__F_102467 + N_102385__F_102395 => N_102385__F_102470 + N_102385__F_102395 => N_102385__F_102478 + N_102385__F_102395 => N_102385__F_102481 + N_102385__F_102395 => N_102385__F_102487 + N_102385__F_102395 => N_102385__F_102492 + N_102385__F_102396 => N_102385__F_102416 + N_102385__F_102396 => N_102385__F_102431 + N_102385__F_102396 => N_102385__F_102436 + N_102385__F_102396 => N_102385__F_102441 + N_102385__F_102396 => N_102385__F_102444 + N_102385__F_102396 => N_102385__F_102454 + N_102385__F_102396 => N_102385__F_102451 + N_102385__F_102396 => N_102385__F_102460 + N_102385__F_102396 => N_102385__F_102468 + N_102385__F_102396 => N_102385__F_102472 + N_102385__F_102396 => N_102385__F_102478 + N_102385__F_102396 => N_102385__F_102481 + N_102385__F_102396 => N_102385__F_102487 + N_102385__F_102396 => N_102385__F_102493 + N_102385__F_102397 => N_102385__F_102416 + !(N_102385__F_102397 & N_102385__F_102420) + N_102385__F_102397 => N_102385__F_102431 + N_102385__F_102397 => N_102385__F_102436 + N_102385__F_102397 => N_102385__F_102441 + N_102385__F_102397 => N_102385__F_102444 + !(N_102385__F_102397 & N_102385__F_102447) + N_102385__F_102397 => N_102385__F_102460 + N_102385__F_102397 => N_102385__F_102468 + N_102385__F_102397 => N_102385__F_102472 + N_102385__F_102397 => N_102385__F_102477 + N_102385__F_102397 => N_102385__F_102481 + N_102385__F_102397 => N_102385__F_102487 + N_102385__F_102397 => N_102385__F_102496 + N_102385__F_102397 => N_102385__F_102454 + N_102385__F_102397 => N_102385__F_102488 + N_102385__F_102397 => N_104687__F_104692 + N_102385__F_102397 => N_104687__F_104695 + N_102385__F_102398 => N_102385__F_102416 + !(N_102385__F_102398 & N_102385__F_102420) + N_102385__F_102398 => N_102385__F_102431 + N_102385__F_102398 => N_102385__F_102436 + N_102385__F_102398 => N_102385__F_102441 + !(N_102385__F_102398 & N_102385__F_102451) + N_102385__F_102398 => N_102385__F_102454 + N_102385__F_102398 => N_102385__F_102460 + N_102385__F_102398 => N_102385__F_102468 + N_102385__F_102398 => N_102385__F_102477 + N_102385__F_102398 => N_102385__F_102481 + N_102385__F_102398 => N_102385__F_102487 + N_102385__F_102398 => N_102385__F_102496 + N_102385__F_102399 => N_102385__F_102416 + !(N_102385__F_102399 & N_102385__F_102420) + N_102385__F_102399 => N_102385__F_102431 + N_102385__F_102399 => N_102385__F_102436 + N_102385__F_102399 => N_102385__F_102441 + N_102385__F_102399 => N_102385__F_102444 + !(N_102385__F_102399 & N_102385__F_102447) + N_102385__F_102399 => N_102385__F_102454 + N_102385__F_102399 => N_102385__F_102460 + N_102385__F_102399 => N_102385__F_102468 + N_102385__F_102399 => N_102385__F_102472 + N_102385__F_102399 => N_102385__F_102478 + N_102385__F_102399 => N_102385__F_102481 + !(N_102385__F_102399 & "N_102385__F_102483") + N_102385__F_102399 => N_102385__F_102487 + N_102385__F_102399 => N_102385__F_102493 + N_102385__F_102400 => N_102385__F_102415 + N_102385__F_102400 => N_102385__F_102430 + N_102385__F_102400 => N_102385__F_102437 + N_102385__F_102400 => N_102385__F_102441 + N_102385__F_102400 => N_102385__F_102454 + N_102385__F_102400 => N_102385__F_102457 + N_102385__F_102400 => N_102385__F_102467 + N_102385__F_102400 => N_102385__F_102474 + N_102385__F_102400 => N_102385__F_102478 + N_102385__F_102400 => N_102385__F_102481 + N_102385__F_102400 => N_102385__F_102487 + N_102385__F_102400 => N_102385__F_102492 + N_102385__F_102400 => N_102385__F_102445 + !(N_102385__F_102400 & N_102385__F_102451) + N_102385__F_102401 => N_102385__F_102415 + !(N_102385__F_102401 & N_102385__F_102420) + N_102385__F_102401 => N_102385__F_102431 + N_102385__F_102401 => N_102385__F_102436 + N_102385__F_102401 => N_102385__F_102441 + N_102385__F_102401 => N_102385__F_102444 + !(N_102385__F_102401 & N_102385__F_102447) + N_102385__F_102401 => N_102385__F_102454 + N_102385__F_102401 => N_102385__F_102463 + N_102385__F_102401 => N_102385__F_102468 + N_102385__F_102401 => N_102385__F_102472 + N_102385__F_102401 => N_102385__F_102479 + N_102385__F_102401 => N_102385__F_102481 + N_102385__F_102401 => N_102385__F_102487 + N_102385__F_102401 => N_102385__F_102488 + N_102385__F_102401 => N_102385__F_102499 + N_102385__F_102401 => N_104687__F_104692 + N_102385__F_102401 => N_104687__F_104695 + N_102385__F_102402 => N_102385__F_102415 + !(N_102385__F_102402 & N_102385__F_102421) + N_102385__F_102402 => N_102385__F_102431 + N_102385__F_102402 => N_102385__F_102436 + N_102385__F_102402 => N_102385__F_102441 + !(N_102385__F_102402 & N_102385__F_102451) + !(N_102385__F_102402 & N_102385__F_102450) + !(N_102385__F_102402 & N_102385__F_102448) + N_102385__F_102402 => N_102385__F_102454 + N_102385__F_102402 => N_102385__F_102462 + N_102385__F_102402 => N_102385__F_102467 + N_102385__F_102402 => N_102385__F_102474 + N_102385__F_102402 => N_102385__F_102479 + N_102385__F_102402 => N_102385__F_102481 + N_102385__F_102402 => N_102385__F_102487 + N_102385__F_102402 => N_102385__F_102498 + N_102385__F_102402 => N_102385__F_102444 + N_102385__F_102403 => N_102385__F_102417 + !(N_102385__F_102403 & N_102385__F_102420) + N_102385__F_102403 => N_102385__F_102430 + N_102385__F_102403 => N_102385__F_102434 + N_102385__F_102403 => N_102385__F_102439 + N_102385__F_102403 => N_102385__F_102445 + N_102385__F_102403 => N_102385__F_102447 + N_102385__F_102403 => N_102385__F_102453 + N_102385__F_102403 => N_102385__F_102460 + N_102385__F_102403 => N_102385__F_102468 + N_102385__F_102403 => N_102385__F_102478 + N_102385__F_102403 => N_102385__F_102481 + N_102385__F_102403 => N_102385__F_102487 + N_102385__F_102403 => N_102385__F_102495 + N_102385__F_102403 => N_102385__F_102485 + N_102385__F_102404 => N_102385__F_102417 + !(N_102385__F_102404 & N_102385__F_102420) + N_102385__F_102404 => N_102385__F_102430 + N_102385__F_102404 => N_102385__F_102439 + N_102385__F_102404 => N_102385__F_102434 + N_102385__F_102404 => N_102385__F_102447 + N_102385__F_102404 => N_102385__F_102453 + N_102385__F_102404 => N_102385__F_102460 + N_102385__F_102404 => N_102385__F_102468 + N_102385__F_102404 => N_102385__F_102472 + N_102385__F_102404 => N_102385__F_102478 + N_102385__F_102404 => N_102385__F_102481 + N_102385__F_102404 => N_102385__F_102487 + N_102385__F_102404 => N_102385__F_102488 + N_102385__F_102404 => N_102385__F_102496 + N_102385__F_102404 => N_102385__F_102445 + N_102385__F_102404 => N_104687__F_104692 + N_102385__F_102404 => N_104687__F_104695 + N_104357__F_104503 => N_104357__F_104405 + !(N_102385__F_102444 & N_102385__F_102485) + !(N_102385__F_102445 & N_102385__F_102484) + N_102383__I_102504_i_F_102508 => N_102383__I_102504_i_F_102574 + N_102383__I_102504_i_F_102508 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102508 => N_102383__I_102504_i_F_102622 + N_102383__I_102504_i_F_102508 => N_102383__I_102504_i_F_102634 + N_102383__I_102504_i_F_102511 => N_102383__I_102504_i_F_102580 + N_102383__I_102504_i_F_102511 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102511 => N_102383__I_102504_i_F_102622 + N_102383__I_102504_i_F_102511 => N_102383__I_102504_i_F_102634 + N_102383__I_102504_i_F_102514 => N_102383__I_102504_i_F_102583 + N_102383__I_102504_i_F_102514 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102514 => N_102383__I_102504_i_F_102622 + N_102383__I_102504_i_F_102514 => N_102383__I_102504_i_F_102634 + N_102383__I_102504_i_F_102517 => N_102383__I_102504_i_F_102574 + N_102383__I_102504_i_F_102517 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102517 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102517 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102520 => N_102383__I_102504_i_F_102580 + N_102383__I_102504_i_F_102520 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102520 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102520 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102523 => N_102383__I_102504_i_F_102580 + N_102383__I_102504_i_F_102523 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102523 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102523 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102526 => N_102383__I_102504_i_F_102583 + N_102383__I_102504_i_F_102526 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102526 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102526 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102529 => N_102383__I_102504_i_F_102586 + N_102383__I_102504_i_F_102529 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102529 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102529 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102532 => N_102383__I_102504_i_F_102580 + N_102383__I_102504_i_F_102532 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102532 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102532 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102535 => N_102383__I_102504_i_F_102583 + N_102383__I_102504_i_F_102535 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102535 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102535 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102538 => N_102383__I_102504_i_F_102586 + N_102383__I_102504_i_F_102538 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102538 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102538 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102541 => N_102383__I_102504_i_F_102589 + N_102383__I_102504_i_F_102541 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102541 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102541 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102544 => N_102383__I_102504_i_F_102592 + N_102383__I_102504_i_F_102544 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102544 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102544 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102547 => N_102383__I_102504_i_F_102598 + N_102383__I_102504_i_F_102547 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102547 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102547 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102550 => N_102383__I_102504_i_F_102577 + N_102383__I_102504_i_F_102550 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102550 => N_102383__I_102504_i_F_102622 + N_102383__I_102504_i_F_102550 => N_102383__I_102504_i_F_102634 + N_102383__I_102504_i_F_102553 => N_102383__I_102504_i_F_102586 + N_102383__I_102504_i_F_102553 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102553 => N_102383__I_102504_i_F_102622 + N_102383__I_102504_i_F_102553 => N_102383__I_102504_i_F_102634 + N_102383__I_102504_i_F_102556 => N_102383__I_102504_i_F_102601 + N_102383__I_102504_i_F_102556 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102556 => N_102383__I_102504_i_F_102628 + N_102383__I_102504_i_F_102556 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102559 => N_102383__I_102504_i_F_102604 + N_102383__I_102504_i_F_102559 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102559 => N_102383__I_102504_i_F_102628 + N_102383__I_102504_i_F_102559 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102562 => N_102383__I_102504_i_F_102607 + N_102383__I_102504_i_F_102562 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102562 => N_102383__I_102504_i_F_102628 + N_102383__I_102504_i_F_102562 => N_102383__I_102504_i_F_102637 + N_102383__I_102504_i_F_102565 => N_102383__I_102504_i_F_102583 + N_102383__I_102504_i_F_102565 => N_102383__I_102504_i_F_102613 + N_102383__I_102504_i_F_102565 => N_102383__I_102504_i_F_102625 + N_102383__I_102504_i_F_102565 => N_102383__I_102504_i_F_102637 + N_102383__I_102642_i_F_102646 => N_102383__I_102642_i_F_102712 + N_102383__I_102642_i_F_102646 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102646 => N_102383__I_102642_i_F_102760 + N_102383__I_102642_i_F_102646 => N_102383__I_102642_i_F_102772 + N_102383__I_102642_i_F_102649 => N_102383__I_102642_i_F_102718 + N_102383__I_102642_i_F_102649 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102649 => N_102383__I_102642_i_F_102760 + N_102383__I_102642_i_F_102649 => N_102383__I_102642_i_F_102772 + N_102383__I_102642_i_F_102652 => N_102383__I_102642_i_F_102721 + N_102383__I_102642_i_F_102652 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102652 => N_102383__I_102642_i_F_102760 + N_102383__I_102642_i_F_102652 => N_102383__I_102642_i_F_102772 + N_102383__I_102642_i_F_102655 => N_102383__I_102642_i_F_102712 + N_102383__I_102642_i_F_102655 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102655 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102655 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102658 => N_102383__I_102642_i_F_102718 + N_102383__I_102642_i_F_102658 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102658 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102658 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102661 => N_102383__I_102642_i_F_102718 + N_102383__I_102642_i_F_102661 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102661 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102661 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102664 => N_102383__I_102642_i_F_102721 + N_102383__I_102642_i_F_102664 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102664 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102664 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102667 => N_102383__I_102642_i_F_102724 + N_102383__I_102642_i_F_102667 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102667 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102667 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102670 => N_102383__I_102642_i_F_102718 + N_102383__I_102642_i_F_102670 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102670 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102670 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102673 => N_102383__I_102642_i_F_102721 + N_102383__I_102642_i_F_102673 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102673 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102673 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102676 => N_102383__I_102642_i_F_102724 + N_102383__I_102642_i_F_102676 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102676 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102676 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102679 => N_102383__I_102642_i_F_102727 + N_102383__I_102642_i_F_102679 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102679 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102679 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102682 => N_102383__I_102642_i_F_102730 + N_102383__I_102642_i_F_102682 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102682 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102682 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102685 => N_102383__I_102642_i_F_102736 + N_102383__I_102642_i_F_102685 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102685 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102685 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102688 => N_102383__I_102642_i_F_102715 + N_102383__I_102642_i_F_102688 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102688 => N_102383__I_102642_i_F_102760 + N_102383__I_102642_i_F_102688 => N_102383__I_102642_i_F_102772 + N_102383__I_102642_i_F_102691 => N_102383__I_102642_i_F_102724 + N_102383__I_102642_i_F_102691 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102691 => N_102383__I_102642_i_F_102760 + N_102383__I_102642_i_F_102691 => N_102383__I_102642_i_F_102772 + N_102383__I_102642_i_F_102694 => N_102383__I_102642_i_F_102739 + N_102383__I_102642_i_F_102694 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102694 => N_102383__I_102642_i_F_102766 + N_102383__I_102642_i_F_102694 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102697 => N_102383__I_102642_i_F_102742 + N_102383__I_102642_i_F_102697 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102697 => N_102383__I_102642_i_F_102766 + N_102383__I_102642_i_F_102697 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102700 => N_102383__I_102642_i_F_102745 + N_102383__I_102642_i_F_102700 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102700 => N_102383__I_102642_i_F_102766 + N_102383__I_102642_i_F_102700 => N_102383__I_102642_i_F_102775 + N_102383__I_102642_i_F_102703 => N_102383__I_102642_i_F_102721 + N_102383__I_102642_i_F_102703 => N_102383__I_102642_i_F_102751 + N_102383__I_102642_i_F_102703 => N_102383__I_102642_i_F_102763 + N_102383__I_102642_i_F_102703 => N_102383__I_102642_i_F_102775 + N_102383__I_103300_i_F_103304 => N_102383__I_103300_i_F_103352 + N_102383__I_103300_i_F_103304 => N_102383__I_103300_i_F_103463 + N_102383__I_103300_i_F_103307 => N_102383__I_103300_i_F_103352 + !(N_102383__I_103300_i_F_103307 & N_102383__I_103300_i_F_103466) + N_102383__I_103300_i_F_103310 => N_102383__I_103300_i_F_103352 + N_102383__I_103300_i_F_103310 => N_102383__I_103300_i_F_103463 + N_102383__I_103300_i_F_103313 => N_102383__I_103300_i_F_103463 + N_102383__I_103300_i_F_103313 => N_102383__I_103300_i_F_103352 + !(N_102383__I_103300_i_F_103316 & N_102383__I_103300_i_F_103469) + !(N_102383__I_103300_i_F_103316 & N_102383__I_103300_i_F_103358) + !(N_102383__I_103300_i_F_103316 & N_102383__I_103300_i_F_103361) + !(N_102383__I_103300_i_F_103319 & N_102383__I_103300_i_F_103469) + !(N_102383__I_103300_i_F_103319 & N_102383__I_103300_i_F_103358) + !(N_102383__I_103300_i_F_103319 & N_102383__I_103300_i_F_103361) + N_102383__I_103300_i_F_103322 => N_102383__I_103300_i_F_103361 + N_102383__I_103300_i_F_103322 => N_102383__I_103300_i_F_103463 + N_102383__I_103300_i_F_103325 => N_102383__I_103300_i_F_103358 + N_102383__I_103300_i_F_103325 => N_102383__I_103300_i_F_103463 + N_102383__I_103300_i_F_103328 => N_102383__I_103300_i_F_103352 + N_102383__I_103300_i_F_103328 => N_102383__I_103300_i_F_103463 + N_102383__I_103300_i_F_103331 => N_102383__I_103300_i_F_103352 + N_102383__I_103300_i_F_103331 => N_102383__I_103300_i_F_103463 + N_102383__I_103300_i_F_103334 => N_102383__I_103300_i_F_103355 + N_102383__I_103300_i_F_103334 => N_102383__I_103300_i_F_103466 + !(N_102383__I_103300_i_F_103337 & N_102383__I_103300_i_F_103358) + !(N_102383__I_103300_i_F_103337 & N_102383__I_103300_i_F_103361) + !(N_102383__I_103300_i_F_103337 & N_102383__I_103300_i_F_103469) + !(N_102383__I_103300_i_F_103340 & N_102383__I_103300_i_F_103358) + !(N_102383__I_103300_i_F_103340 & N_102383__I_103300_i_F_103361) + !(N_102383__I_103300_i_F_103340 & N_102383__I_103300_i_F_103469) + N_102383__I_103300_i_F_103343 => N_102383__I_103300_i_F_103361 + N_102383__I_103300_i_F_103343 => N_102383__I_103300_i_F_103463 + N_102383__I_103546_i_F_103550 => N_102383__I_103546_i_F_103598 + N_102383__I_103546_i_F_103550 => N_102383__I_103546_i_F_103709 + N_102383__I_103546_i_F_103553 => N_102383__I_103546_i_F_103598 + !(N_102383__I_103546_i_F_103553 & N_102383__I_103546_i_F_103712) + N_102383__I_103546_i_F_103556 => N_102383__I_103546_i_F_103598 + N_102383__I_103546_i_F_103556 => N_102383__I_103546_i_F_103709 + N_102383__I_103546_i_F_103559 => N_102383__I_103546_i_F_103709 + N_102383__I_103546_i_F_103559 => N_102383__I_103546_i_F_103598 + !(N_102383__I_103546_i_F_103562 & N_102383__I_103546_i_F_103715) + !(N_102383__I_103546_i_F_103562 & N_102383__I_103546_i_F_103604) + !(N_102383__I_103546_i_F_103562 & N_102383__I_103546_i_F_103607) + !(N_102383__I_103546_i_F_103565 & N_102383__I_103546_i_F_103715) + !(N_102383__I_103546_i_F_103565 & N_102383__I_103546_i_F_103604) + !(N_102383__I_103546_i_F_103565 & N_102383__I_103546_i_F_103607) + N_102383__I_103546_i_F_103568 => N_102383__I_103546_i_F_103607 + N_102383__I_103546_i_F_103568 => N_102383__I_103546_i_F_103709 + N_102383__I_103546_i_F_103571 => N_102383__I_103546_i_F_103604 + N_102383__I_103546_i_F_103571 => N_102383__I_103546_i_F_103709 + N_102383__I_103546_i_F_103574 => N_102383__I_103546_i_F_103598 + N_102383__I_103546_i_F_103574 => N_102383__I_103546_i_F_103709 + N_102383__I_103546_i_F_103577 => N_102383__I_103546_i_F_103598 + N_102383__I_103546_i_F_103577 => N_102383__I_103546_i_F_103709 + N_102383__I_103546_i_F_103580 => N_102383__I_103546_i_F_103601 + N_102383__I_103546_i_F_103580 => N_102383__I_103546_i_F_103712 + !(N_102383__I_103546_i_F_103583 & N_102383__I_103546_i_F_103604) + !(N_102383__I_103546_i_F_103583 & N_102383__I_103546_i_F_103607) + !(N_102383__I_103546_i_F_103583 & N_102383__I_103546_i_F_103715) + !(N_102383__I_103546_i_F_103586 & N_102383__I_103546_i_F_103604) + !(N_102383__I_103546_i_F_103586 & N_102383__I_103546_i_F_103607) + !(N_102383__I_103546_i_F_103586 & N_102383__I_103546_i_F_103715) + N_102383__I_103546_i_F_103589 => N_102383__I_103546_i_F_103607 + N_102383__I_103546_i_F_103589 => N_102383__I_103546_i_F_103709 + N_102383__I_103792_i_F_103796 => N_102383__I_103792_i_F_103844 + N_102383__I_103792_i_F_103796 => N_102383__I_103792_i_F_103955 + N_102383__I_103792_i_F_103799 => N_102383__I_103792_i_F_103844 + !(N_102383__I_103792_i_F_103799 & N_102383__I_103792_i_F_103958) + N_102383__I_103792_i_F_103802 => N_102383__I_103792_i_F_103844 + N_102383__I_103792_i_F_103802 => N_102383__I_103792_i_F_103955 + N_102383__I_103792_i_F_103805 => N_102383__I_103792_i_F_103955 + N_102383__I_103792_i_F_103805 => N_102383__I_103792_i_F_103844 + !(N_102383__I_103792_i_F_103808 & N_102383__I_103792_i_F_103961) + !(N_102383__I_103792_i_F_103808 & N_102383__I_103792_i_F_103850) + !(N_102383__I_103792_i_F_103808 & N_102383__I_103792_i_F_103853) + !(N_102383__I_103792_i_F_103811 & N_102383__I_103792_i_F_103961) + !(N_102383__I_103792_i_F_103811 & N_102383__I_103792_i_F_103850) + !(N_102383__I_103792_i_F_103811 & N_102383__I_103792_i_F_103853) + N_102383__I_103792_i_F_103814 => N_102383__I_103792_i_F_103853 + N_102383__I_103792_i_F_103814 => N_102383__I_103792_i_F_103955 + N_102383__I_103792_i_F_103817 => N_102383__I_103792_i_F_103850 + N_102383__I_103792_i_F_103817 => N_102383__I_103792_i_F_103955 + N_102383__I_103792_i_F_103820 => N_102383__I_103792_i_F_103844 + N_102383__I_103792_i_F_103820 => N_102383__I_103792_i_F_103955 + N_102383__I_103792_i_F_103823 => N_102383__I_103792_i_F_103844 + N_102383__I_103792_i_F_103823 => N_102383__I_103792_i_F_103955 + N_102383__I_103792_i_F_103826 => N_102383__I_103792_i_F_103847 + N_102383__I_103792_i_F_103826 => N_102383__I_103792_i_F_103958 + !(N_102383__I_103792_i_F_103829 & N_102383__I_103792_i_F_103850) + !(N_102383__I_103792_i_F_103829 & N_102383__I_103792_i_F_103853) + !(N_102383__I_103792_i_F_103829 & N_102383__I_103792_i_F_103961) + !(N_102383__I_103792_i_F_103832 & N_102383__I_103792_i_F_103850) + !(N_102383__I_103792_i_F_103832 & N_102383__I_103792_i_F_103853) + !(N_102383__I_103792_i_F_103832 & N_102383__I_103792_i_F_103961) + N_102383__I_103792_i_F_103835 => N_102383__I_103792_i_F_103853 + N_102383__I_103792_i_F_103835 => N_102383__I_103792_i_F_103955 + N_102383__I_104038_i_F_104042 => N_102383__I_104038_i_F_104090 + N_102383__I_104038_i_F_104042 => N_102383__I_104038_i_F_104201 + N_102383__I_104038_i_F_104045 => N_102383__I_104038_i_F_104090 + !(N_102383__I_104038_i_F_104045 & N_102383__I_104038_i_F_104204) + N_102383__I_104038_i_F_104048 => N_102383__I_104038_i_F_104090 + N_102383__I_104038_i_F_104048 => N_102383__I_104038_i_F_104201 + N_102383__I_104038_i_F_104051 => N_102383__I_104038_i_F_104201 + N_102383__I_104038_i_F_104051 => N_102383__I_104038_i_F_104090 + !(N_102383__I_104038_i_F_104054 & N_102383__I_104038_i_F_104207) + !(N_102383__I_104038_i_F_104054 & N_102383__I_104038_i_F_104096) + !(N_102383__I_104038_i_F_104054 & N_102383__I_104038_i_F_104099) + !(N_102383__I_104038_i_F_104057 & N_102383__I_104038_i_F_104207) + !(N_102383__I_104038_i_F_104057 & N_102383__I_104038_i_F_104096) + !(N_102383__I_104038_i_F_104057 & N_102383__I_104038_i_F_104099) + N_102383__I_104038_i_F_104060 => N_102383__I_104038_i_F_104099 + N_102383__I_104038_i_F_104060 => N_102383__I_104038_i_F_104201 + N_102383__I_104038_i_F_104063 => N_102383__I_104038_i_F_104096 + N_102383__I_104038_i_F_104063 => N_102383__I_104038_i_F_104201 + N_102383__I_104038_i_F_104066 => N_102383__I_104038_i_F_104090 + N_102383__I_104038_i_F_104066 => N_102383__I_104038_i_F_104201 + N_102383__I_104038_i_F_104069 => N_102383__I_104038_i_F_104090 + N_102383__I_104038_i_F_104069 => N_102383__I_104038_i_F_104201 + N_102383__I_104038_i_F_104072 => N_102383__I_104038_i_F_104093 + N_102383__I_104038_i_F_104072 => N_102383__I_104038_i_F_104204 + !(N_102383__I_104038_i_F_104075 & N_102383__I_104038_i_F_104096) + !(N_102383__I_104038_i_F_104075 & N_102383__I_104038_i_F_104099) + !(N_102383__I_104038_i_F_104075 & N_102383__I_104038_i_F_104207) + !(N_102383__I_104038_i_F_104078 & N_102383__I_104038_i_F_104096) + !(N_102383__I_104038_i_F_104078 & N_102383__I_104038_i_F_104099) + !(N_102383__I_104038_i_F_104078 & N_102383__I_104038_i_F_104207) + N_102383__I_104038_i_F_104081 => N_102383__I_104038_i_F_104099 + N_102383__I_104038_i_F_104081 => N_102383__I_104038_i_F_104201 + !(N_102385__F_102461 & N_102385__F_102464) + !(N_102385__F_102461 & N_102385__F_102460) + N_102383__I_102808_i_F_102815 => N_102383__I_102808_i_F_102824 + N_102383__I_102808_i_F_102815 => N_102383__I_102808_i_F_102839 + N_102383__I_102808_i_F_102815 => N_102383__I_102808_i_F_102830 + N_102383__I_102808_i_F_102818 => N_102383__I_102808_i_F_102824 + N_102383__I_102808_i_F_102818 => N_102383__I_102808_i_F_102842 + N_102383__I_102808_i_F_102818 => N_102383__I_102808_i_F_102833 + N_102383__I_102808_i_F_102818 => N_102383__I_102808_i_F_102887 + N_102383__I_102808_i_F_102881 => N_102383__I_102808_i_F_103001 + !(N_102383__I_102808_i_F_102884 & N_102383__I_102808_i_F_103013) + N_102383__I_102808_i_F_102884 => N_102383__I_102808_i_F_103004 + N_102383__I_102808_i_F_102899 => N_102383__I_102808_i_F_102911 + N_102383__I_102808_i_F_102899 => N_102383__I_102808_i_F_102983 + N_102383__I_102808_i_F_102899 => N_102383__I_102808_i_F_102971 + N_102383__I_102808_i_F_102902 => N_102383__I_102808_i_F_102911 + N_102383__I_102808_i_F_102902 => N_102383__I_102808_i_F_102977 + N_102383__I_102808_i_F_102902 => N_102383__I_102808_i_F_102962 + N_102383__I_102808_i_F_102905 => N_102383__I_102808_i_F_102911 + N_102383__I_102808_i_F_102905 => N_102383__I_102808_i_F_102980 + N_102383__I_102808_i_F_102905 => N_102383__I_102808_i_F_102965 + N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102815 + N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102902 + N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102851 + N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102920 + N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102815 + N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102902 + N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102851 + N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102920 + N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102818 + N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102902 + N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102854 + N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102920 + N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102818 + N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102902 + N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102854 + N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102920 + N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102818 + N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102905 + N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102857 + N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102926 + N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102992 + N_102383__I_102808_i_F_103025 => "N_102383__I_102808_i_F_102812" + N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102857 + N_102383__I_102808_i_F_103025 => "N_102383__I_102808_i_F_102896" + N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102992 + N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102818 + N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102926 + N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102905 + N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102899 + N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102815 + N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102851 + N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102929 + N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102992 + N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102815 + N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102899 + N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102851 + N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102929 + N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102992 + N_102383__I_102808_i_F_103034 => N_102383__I_102808_i_F_102815 + N_102383__I_102808_i_F_103034 => N_102383__I_102808_i_F_102902 + N_102383__I_102808_i_F_103034 => N_102383__I_102808_i_F_102920 + N_102383__I_102808_i_F_103034 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_103037 => N_102383__I_102808_i_F_102815 + N_102383__I_102808_i_F_103037 => N_102383__I_102808_i_F_102902 + N_102383__I_102808_i_F_103037 => N_102383__I_102808_i_F_102920 + N_102383__I_102808_i_F_103037 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102818 + N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102857 + N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102905 + N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102926 + N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102992 + N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102818 + N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102857 + N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102905 + N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102926 + N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102992 + N_102383__I_102808_i_F_103046 => "N_102383__I_102808_i_F_102812" + N_102383__I_102808_i_F_103046 => N_102383__I_102808_i_F_102857 + N_102383__I_102808_i_F_103046 => N_102383__I_102808_i_F_102905 + N_102383__I_102808_i_F_103046 => N_102383__I_102808_i_F_102992 + N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102815 + N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102851 + N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102899 + N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102929 + N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102992 + N_102383__I_103054_i_F_103061 => N_102383__I_103054_i_F_103070 + N_102383__I_103054_i_F_103061 => N_102383__I_103054_i_F_103085 + N_102383__I_103054_i_F_103061 => N_102383__I_103054_i_F_103076 + N_102383__I_103054_i_F_103064 => N_102383__I_103054_i_F_103070 + N_102383__I_103054_i_F_103064 => N_102383__I_103054_i_F_103088 + N_102383__I_103054_i_F_103064 => N_102383__I_103054_i_F_103079 + N_102383__I_103054_i_F_103064 => N_102383__I_103054_i_F_103133 + N_102383__I_103054_i_F_103127 => N_102383__I_103054_i_F_103247 + !(N_102383__I_103054_i_F_103130 & N_102383__I_103054_i_F_103259) + N_102383__I_103054_i_F_103130 => N_102383__I_103054_i_F_103250 + N_102383__I_103054_i_F_103145 => N_102383__I_103054_i_F_103157 + N_102383__I_103054_i_F_103145 => N_102383__I_103054_i_F_103229 + N_102383__I_103054_i_F_103145 => N_102383__I_103054_i_F_103217 + N_102383__I_103054_i_F_103148 => N_102383__I_103054_i_F_103157 + N_102383__I_103054_i_F_103148 => N_102383__I_103054_i_F_103223 + N_102383__I_103054_i_F_103148 => N_102383__I_103054_i_F_103208 + N_102383__I_103054_i_F_103151 => N_102383__I_103054_i_F_103157 + N_102383__I_103054_i_F_103151 => N_102383__I_103054_i_F_103226 + N_102383__I_103054_i_F_103151 => N_102383__I_103054_i_F_103211 + N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103148 + N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103097 + N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103166 + N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103148 + N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103097 + N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103166 + N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103064 + N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103148 + N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103100 + N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103166 + N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103064 + N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103148 + N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103100 + N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103166 + N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103064 + N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103151 + N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103103 + N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103172 + N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103238 + N_102383__I_103054_i_F_103271 => "N_102383__I_103054_i_F_103058" + N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103103 + N_102383__I_103054_i_F_103271 => "N_102383__I_103054_i_F_103142" + N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103238 + N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103148 + N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103169 + N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103145 + N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103097 + N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103175 + N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103238 + N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103145 + N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103097 + N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103175 + N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103238 + N_102383__I_103054_i_F_103280 => N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103280 => N_102383__I_103054_i_F_103148 + N_102383__I_103054_i_F_103280 => N_102383__I_103054_i_F_103166 + N_102383__I_103054_i_F_103280 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103283 => N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103283 => N_102383__I_103054_i_F_103148 + N_102383__I_103054_i_F_103283 => N_102383__I_103054_i_F_103166 + N_102383__I_103054_i_F_103283 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103064 + N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103103 + N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103151 + N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103172 + N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103238 + N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103064 + N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103103 + N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103151 + N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103172 + N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103238 + N_102383__I_103054_i_F_103292 => "N_102383__I_103054_i_F_103058" + N_102383__I_103054_i_F_103292 => N_102383__I_103054_i_F_103103 + N_102383__I_103054_i_F_103292 => N_102383__I_103054_i_F_103151 + N_102383__I_103054_i_F_103292 => N_102383__I_103054_i_F_103238 + N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103061 + N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103097 + N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103145 + N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103175 + N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103238 + N_102383__I_103300_i_F_103352 => N_102383__I_103300_i_F_103442 + N_102383__I_103300_i_F_103352 => N_102383__I_103300_i_F_103391 + N_102383__I_103300_i_F_103352 => N_102383__I_103300_i_F_103433 + !(N_102383__I_103300_i_F_103352 & N_102383__I_103300_i_F_103367) + !(N_102383__I_103300_i_F_103352 & N_102383__I_103300_i_F_103379) + !(N_102383__I_103300_i_F_103352 & N_102383__I_103300_i_F_103382) + N_102383__I_103300_i_F_103352 => N_102383__I_103300_i_F_103451 + N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103442 + N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103433 + N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103397 + N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103367 + N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103451 + N_102383__I_103300_i_F_103358 => N_102383__I_103300_i_F_103433 + N_102383__I_103300_i_F_103358 => N_102383__I_103300_i_F_103394 + N_102383__I_103300_i_F_103358 => N_102383__I_103300_i_F_103445 + !(N_102383__I_103300_i_F_103358 & N_102383__I_103300_i_F_103367) + !(N_102383__I_103300_i_F_103358 & N_102383__I_103300_i_F_103370) + !(N_102383__I_103300_i_F_103358 & N_102383__I_103300_i_F_103373) + !(N_102383__I_103300_i_F_103358 & N_102383__I_103300_i_F_103376) + !(N_102383__I_103300_i_F_103358 & "N_102383__I_103300_i_F_103448") + N_102383__I_103300_i_F_103361 => N_102383__I_103300_i_F_103436 + N_102383__I_103300_i_F_103361 => N_102383__I_103300_i_F_103445 + N_102383__I_103300_i_F_103361 => N_102383__I_103300_i_F_103391 + !(N_102383__I_103300_i_F_103361 & N_102383__I_103300_i_F_103367) + !(N_102383__I_103300_i_F_103361 & N_102383__I_103300_i_F_103370) + !(N_102383__I_103300_i_F_103361 & N_102383__I_103300_i_F_103373) + !(N_102383__I_103300_i_F_103361 & N_102383__I_103300_i_F_103376) + !(N_102383__I_103300_i_F_103361 & "N_102383__I_103300_i_F_103448") + N_102383__I_103300_i_F_103463 => N_102383__I_103300_i_F_103541 + N_102383__I_103300_i_F_103463 => N_102383__I_103300_i_F_103493 + N_102383__I_103300_i_F_103463 => N_102383__I_103300_i_F_103535 + !(N_102383__I_103300_i_F_103463 & N_102383__I_103300_i_F_103475) + N_102383__I_103300_i_F_103466 => N_102383__I_103300_i_F_103541 + N_102383__I_103300_i_F_103466 => N_102383__I_103300_i_F_103535 + N_102383__I_103300_i_F_103466 => N_102383__I_103300_i_F_103499 + N_102383__I_103300_i_F_103466 => N_102383__I_103300_i_F_103475 + N_102383__I_103300_i_F_103469 => N_102383__I_103300_i_F_103541 + N_102383__I_103300_i_F_103469 => N_102383__I_103300_i_F_103496 + N_102383__I_103300_i_F_103469 => N_102383__I_103300_i_F_103535 + !(N_102383__I_103300_i_F_103469 & N_102383__I_103300_i_F_103475) + N_102383__I_103546_i_F_103598 => N_102383__I_103546_i_F_103688 + N_102383__I_103546_i_F_103598 => N_102383__I_103546_i_F_103637 + N_102383__I_103546_i_F_103598 => N_102383__I_103546_i_F_103679 + !(N_102383__I_103546_i_F_103598 & N_102383__I_103546_i_F_103613) + !(N_102383__I_103546_i_F_103598 & N_102383__I_103546_i_F_103625) + !(N_102383__I_103546_i_F_103598 & N_102383__I_103546_i_F_103628) + N_102383__I_103546_i_F_103598 => N_102383__I_103546_i_F_103697 + N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103688 + N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103679 + N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103643 + N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103613 + N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103697 + N_102383__I_103546_i_F_103604 => N_102383__I_103546_i_F_103679 + N_102383__I_103546_i_F_103604 => N_102383__I_103546_i_F_103640 + N_102383__I_103546_i_F_103604 => N_102383__I_103546_i_F_103691 + !(N_102383__I_103546_i_F_103604 & N_102383__I_103546_i_F_103613) + !(N_102383__I_103546_i_F_103604 & N_102383__I_103546_i_F_103616) + !(N_102383__I_103546_i_F_103604 & N_102383__I_103546_i_F_103619) + !(N_102383__I_103546_i_F_103604 & N_102383__I_103546_i_F_103622) + !(N_102383__I_103546_i_F_103604 & "N_102383__I_103546_i_F_103694") + N_102383__I_103546_i_F_103607 => N_102383__I_103546_i_F_103682 + N_102383__I_103546_i_F_103607 => N_102383__I_103546_i_F_103691 + N_102383__I_103546_i_F_103607 => N_102383__I_103546_i_F_103637 + !(N_102383__I_103546_i_F_103607 & N_102383__I_103546_i_F_103613) + !(N_102383__I_103546_i_F_103607 & N_102383__I_103546_i_F_103616) + !(N_102383__I_103546_i_F_103607 & N_102383__I_103546_i_F_103619) + !(N_102383__I_103546_i_F_103607 & N_102383__I_103546_i_F_103622) + !(N_102383__I_103546_i_F_103607 & "N_102383__I_103546_i_F_103694") + N_102383__I_103546_i_F_103709 => N_102383__I_103546_i_F_103787 + N_102383__I_103546_i_F_103709 => N_102383__I_103546_i_F_103739 + N_102383__I_103546_i_F_103709 => N_102383__I_103546_i_F_103781 + !(N_102383__I_103546_i_F_103709 & N_102383__I_103546_i_F_103721) + N_102383__I_103546_i_F_103712 => N_102383__I_103546_i_F_103787 + N_102383__I_103546_i_F_103712 => N_102383__I_103546_i_F_103781 + N_102383__I_103546_i_F_103712 => N_102383__I_103546_i_F_103745 + N_102383__I_103546_i_F_103712 => N_102383__I_103546_i_F_103721 + N_102383__I_103546_i_F_103715 => N_102383__I_103546_i_F_103787 + N_102383__I_103546_i_F_103715 => N_102383__I_103546_i_F_103742 + N_102383__I_103546_i_F_103715 => N_102383__I_103546_i_F_103781 + !(N_102383__I_103546_i_F_103715 & N_102383__I_103546_i_F_103721) + N_102383__I_103792_i_F_103844 => N_102383__I_103792_i_F_103934 + N_102383__I_103792_i_F_103844 => N_102383__I_103792_i_F_103883 + N_102383__I_103792_i_F_103844 => N_102383__I_103792_i_F_103925 + !(N_102383__I_103792_i_F_103844 & N_102383__I_103792_i_F_103859) + !(N_102383__I_103792_i_F_103844 & N_102383__I_103792_i_F_103871) + !(N_102383__I_103792_i_F_103844 & N_102383__I_103792_i_F_103874) + N_102383__I_103792_i_F_103844 => N_102383__I_103792_i_F_103943 + N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103934 + N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103925 + N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103889 + N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103859 + N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103943 + N_102383__I_103792_i_F_103850 => N_102383__I_103792_i_F_103925 + N_102383__I_103792_i_F_103850 => N_102383__I_103792_i_F_103886 + N_102383__I_103792_i_F_103850 => N_102383__I_103792_i_F_103937 + !(N_102383__I_103792_i_F_103850 & N_102383__I_103792_i_F_103859) + !(N_102383__I_103792_i_F_103850 & N_102383__I_103792_i_F_103862) + !(N_102383__I_103792_i_F_103850 & N_102383__I_103792_i_F_103865) + !(N_102383__I_103792_i_F_103850 & N_102383__I_103792_i_F_103868) + !(N_102383__I_103792_i_F_103850 & "N_102383__I_103792_i_F_103940") + N_102383__I_103792_i_F_103853 => N_102383__I_103792_i_F_103928 + N_102383__I_103792_i_F_103853 => N_102383__I_103792_i_F_103937 + N_102383__I_103792_i_F_103853 => N_102383__I_103792_i_F_103883 + !(N_102383__I_103792_i_F_103853 & N_102383__I_103792_i_F_103859) + !(N_102383__I_103792_i_F_103853 & N_102383__I_103792_i_F_103862) + !(N_102383__I_103792_i_F_103853 & N_102383__I_103792_i_F_103865) + !(N_102383__I_103792_i_F_103853 & N_102383__I_103792_i_F_103868) + !(N_102383__I_103792_i_F_103853 & "N_102383__I_103792_i_F_103940") + N_102383__I_103792_i_F_103955 => N_102383__I_103792_i_F_104033 + N_102383__I_103792_i_F_103955 => N_102383__I_103792_i_F_103985 + N_102383__I_103792_i_F_103955 => N_102383__I_103792_i_F_104027 + !(N_102383__I_103792_i_F_103955 & N_102383__I_103792_i_F_103967) + N_102383__I_103792_i_F_103958 => N_102383__I_103792_i_F_104033 + N_102383__I_103792_i_F_103958 => N_102383__I_103792_i_F_104027 + N_102383__I_103792_i_F_103958 => N_102383__I_103792_i_F_103991 + N_102383__I_103792_i_F_103958 => N_102383__I_103792_i_F_103967 + N_102383__I_103792_i_F_103961 => N_102383__I_103792_i_F_104033 + N_102383__I_103792_i_F_103961 => N_102383__I_103792_i_F_103988 + N_102383__I_103792_i_F_103961 => N_102383__I_103792_i_F_104027 + !(N_102383__I_103792_i_F_103961 & N_102383__I_103792_i_F_103967) + N_102383__I_104038_i_F_104090 => N_102383__I_104038_i_F_104180 + N_102383__I_104038_i_F_104090 => N_102383__I_104038_i_F_104129 + N_102383__I_104038_i_F_104090 => N_102383__I_104038_i_F_104171 + !(N_102383__I_104038_i_F_104090 & N_102383__I_104038_i_F_104105) + !(N_102383__I_104038_i_F_104090 & N_102383__I_104038_i_F_104117) + !(N_102383__I_104038_i_F_104090 & N_102383__I_104038_i_F_104120) + N_102383__I_104038_i_F_104090 => N_102383__I_104038_i_F_104189 + N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104180 + N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104171 + N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104135 + N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104105 + N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104189 + N_102383__I_104038_i_F_104096 => N_102383__I_104038_i_F_104171 + N_102383__I_104038_i_F_104096 => N_102383__I_104038_i_F_104132 + N_102383__I_104038_i_F_104096 => N_102383__I_104038_i_F_104183 + !(N_102383__I_104038_i_F_104096 & N_102383__I_104038_i_F_104105) + !(N_102383__I_104038_i_F_104096 & N_102383__I_104038_i_F_104108) + !(N_102383__I_104038_i_F_104096 & N_102383__I_104038_i_F_104111) + !(N_102383__I_104038_i_F_104096 & N_102383__I_104038_i_F_104114) + !(N_102383__I_104038_i_F_104096 & "N_102383__I_104038_i_F_104186") + N_102383__I_104038_i_F_104099 => N_102383__I_104038_i_F_104174 + N_102383__I_104038_i_F_104099 => N_102383__I_104038_i_F_104183 + N_102383__I_104038_i_F_104099 => N_102383__I_104038_i_F_104129 + !(N_102383__I_104038_i_F_104099 & N_102383__I_104038_i_F_104105) + !(N_102383__I_104038_i_F_104099 & N_102383__I_104038_i_F_104108) + !(N_102383__I_104038_i_F_104099 & N_102383__I_104038_i_F_104111) + !(N_102383__I_104038_i_F_104099 & N_102383__I_104038_i_F_104114) + !(N_102383__I_104038_i_F_104099 & "N_102383__I_104038_i_F_104186") + N_102383__I_104038_i_F_104201 => N_102383__I_104038_i_F_104279 + N_102383__I_104038_i_F_104201 => N_102383__I_104038_i_F_104231 + N_102383__I_104038_i_F_104201 => N_102383__I_104038_i_F_104273 + !(N_102383__I_104038_i_F_104201 & N_102383__I_104038_i_F_104213) + N_102383__I_104038_i_F_104204 => N_102383__I_104038_i_F_104279 + N_102383__I_104038_i_F_104204 => N_102383__I_104038_i_F_104273 + N_102383__I_104038_i_F_104204 => N_102383__I_104038_i_F_104237 + N_102383__I_104038_i_F_104204 => N_102383__I_104038_i_F_104213 + N_102383__I_104038_i_F_104207 => N_102383__I_104038_i_F_104279 + N_102383__I_104038_i_F_104207 => N_102383__I_104038_i_F_104234 + N_102383__I_104038_i_F_104207 => N_102383__I_104038_i_F_104273 + !(N_102383__I_104038_i_F_104207 & N_102383__I_104038_i_F_104213) + N_102383__I_102808_i_F_102965 => N_102383__I_102808_i_F_102980 + N_102383__I_102808_i_F_103001 => N_102383__I_102808_i_F_102881 + !(N_102383__I_102808_i_F_103004 & N_102383__I_102808_i_F_103013) + N_102383__I_102808_i_F_103004 => N_102383__I_102808_i_F_102884 + N_102383__I_103054_i_F_103211 => N_102383__I_103054_i_F_103226 + N_102383__I_103054_i_F_103247 => N_102383__I_103054_i_F_103127 + !(N_102383__I_103054_i_F_103250 & N_102383__I_103054_i_F_103259) + N_102383__I_103054_i_F_103250 => N_102383__I_103054_i_F_103130 + N_102383__I_103300_i_F_103391 => N_102383__I_103300_i_F_103403 + N_102383__I_103300_i_F_103391 => N_102383__I_103300_i_F_103415 + N_102383__I_103300_i_F_103391 => N_102383__I_103300_i_F_103421 + N_102383__I_103300_i_F_103391 => N_102383__I_103300_i_F_103427 + N_102383__I_103300_i_F_103394 => N_102383__I_103300_i_F_103403 + N_102383__I_103300_i_F_103394 => N_102383__I_103300_i_F_103415 + N_102383__I_103300_i_F_103394 => N_102383__I_103300_i_F_103421 + !(N_102383__I_103300_i_F_103394 & N_102383__I_103300_i_F_103427) + N_102383__I_103300_i_F_103397 => N_102383__I_103300_i_F_103412 + N_102383__I_103300_i_F_103397 => N_102383__I_103300_i_F_103406 + N_102383__I_103300_i_F_103397 => N_102383__I_103300_i_F_103424 + N_102383__I_103300_i_F_103397 => N_102383__I_103300_i_F_103427 + N_102383__I_103300_i_F_103493 => N_102383__I_103300_i_F_103505 + N_102383__I_103300_i_F_103493 => N_102383__I_103300_i_F_103523 + N_102383__I_103300_i_F_103493 => N_102383__I_103300_i_F_103517 + !(N_102383__I_103300_i_F_103493 & N_102383__I_103300_i_F_103529) + N_102383__I_103300_i_F_103496 => N_102383__I_103300_i_F_103505 + N_102383__I_103300_i_F_103496 => N_102383__I_103300_i_F_103517 + N_102383__I_103300_i_F_103496 => N_102383__I_103300_i_F_103523 + N_102383__I_103300_i_F_103496 => N_102383__I_103300_i_F_103529 + N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103514 + N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103508 + N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103514 + N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103526 + N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103535 + !(N_102383__I_103300_i_F_103499 & N_102383__I_103300_i_F_103529) + N_102383__I_103546_i_F_103637 => N_102383__I_103546_i_F_103649 + N_102383__I_103546_i_F_103637 => N_102383__I_103546_i_F_103661 + N_102383__I_103546_i_F_103637 => N_102383__I_103546_i_F_103667 + N_102383__I_103546_i_F_103637 => N_102383__I_103546_i_F_103673 + N_102383__I_103546_i_F_103640 => N_102383__I_103546_i_F_103649 + N_102383__I_103546_i_F_103640 => N_102383__I_103546_i_F_103661 + N_102383__I_103546_i_F_103640 => N_102383__I_103546_i_F_103667 + !(N_102383__I_103546_i_F_103640 & N_102383__I_103546_i_F_103673) + N_102383__I_103546_i_F_103643 => N_102383__I_103546_i_F_103658 + N_102383__I_103546_i_F_103643 => N_102383__I_103546_i_F_103652 + N_102383__I_103546_i_F_103643 => N_102383__I_103546_i_F_103670 + N_102383__I_103546_i_F_103643 => N_102383__I_103546_i_F_103673 + N_102383__I_103546_i_F_103739 => N_102383__I_103546_i_F_103751 + N_102383__I_103546_i_F_103739 => N_102383__I_103546_i_F_103769 + N_102383__I_103546_i_F_103739 => N_102383__I_103546_i_F_103763 + !(N_102383__I_103546_i_F_103739 & N_102383__I_103546_i_F_103775) + N_102383__I_103546_i_F_103742 => N_102383__I_103546_i_F_103751 + N_102383__I_103546_i_F_103742 => N_102383__I_103546_i_F_103763 + N_102383__I_103546_i_F_103742 => N_102383__I_103546_i_F_103769 + N_102383__I_103546_i_F_103742 => N_102383__I_103546_i_F_103775 + N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103760 + N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103754 + N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103760 + N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103772 + N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103781 + !(N_102383__I_103546_i_F_103745 & N_102383__I_103546_i_F_103775) + N_102383__I_103792_i_F_103883 => N_102383__I_103792_i_F_103895 + N_102383__I_103792_i_F_103883 => N_102383__I_103792_i_F_103907 + N_102383__I_103792_i_F_103883 => N_102383__I_103792_i_F_103913 + N_102383__I_103792_i_F_103883 => N_102383__I_103792_i_F_103919 + N_102383__I_103792_i_F_103886 => N_102383__I_103792_i_F_103895 + N_102383__I_103792_i_F_103886 => N_102383__I_103792_i_F_103907 + N_102383__I_103792_i_F_103886 => N_102383__I_103792_i_F_103913 + !(N_102383__I_103792_i_F_103886 & N_102383__I_103792_i_F_103919) + N_102383__I_103792_i_F_103889 => N_102383__I_103792_i_F_103904 + N_102383__I_103792_i_F_103889 => N_102383__I_103792_i_F_103898 + N_102383__I_103792_i_F_103889 => N_102383__I_103792_i_F_103916 + N_102383__I_103792_i_F_103889 => N_102383__I_103792_i_F_103919 + N_102383__I_103792_i_F_103985 => N_102383__I_103792_i_F_103997 + N_102383__I_103792_i_F_103985 => N_102383__I_103792_i_F_104015 + N_102383__I_103792_i_F_103985 => N_102383__I_103792_i_F_104009 + !(N_102383__I_103792_i_F_103985 & N_102383__I_103792_i_F_104021) + N_102383__I_103792_i_F_103988 => N_102383__I_103792_i_F_103997 + N_102383__I_103792_i_F_103988 => N_102383__I_103792_i_F_104009 + N_102383__I_103792_i_F_103988 => N_102383__I_103792_i_F_104015 + N_102383__I_103792_i_F_103988 => N_102383__I_103792_i_F_104021 + N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104006 + N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104000 + N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104006 + N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104018 + N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104027 + !(N_102383__I_103792_i_F_103991 & N_102383__I_103792_i_F_104021) + N_102383__I_104038_i_F_104129 => N_102383__I_104038_i_F_104141 + N_102383__I_104038_i_F_104129 => N_102383__I_104038_i_F_104153 + N_102383__I_104038_i_F_104129 => N_102383__I_104038_i_F_104159 + N_102383__I_104038_i_F_104129 => N_102383__I_104038_i_F_104165 + N_102383__I_104038_i_F_104132 => N_102383__I_104038_i_F_104141 + N_102383__I_104038_i_F_104132 => N_102383__I_104038_i_F_104153 + N_102383__I_104038_i_F_104132 => N_102383__I_104038_i_F_104159 + !(N_102383__I_104038_i_F_104132 & N_102383__I_104038_i_F_104165) + N_102383__I_104038_i_F_104135 => N_102383__I_104038_i_F_104150 + N_102383__I_104038_i_F_104135 => N_102383__I_104038_i_F_104144 + N_102383__I_104038_i_F_104135 => N_102383__I_104038_i_F_104162 + N_102383__I_104038_i_F_104135 => N_102383__I_104038_i_F_104165 + N_102383__I_104038_i_F_104231 => N_102383__I_104038_i_F_104243 + N_102383__I_104038_i_F_104231 => N_102383__I_104038_i_F_104261 + N_102383__I_104038_i_F_104231 => N_102383__I_104038_i_F_104255 + !(N_102383__I_104038_i_F_104231 & N_102383__I_104038_i_F_104267) + N_102383__I_104038_i_F_104234 => N_102383__I_104038_i_F_104243 + N_102383__I_104038_i_F_104234 => N_102383__I_104038_i_F_104255 + N_102383__I_104038_i_F_104234 => N_102383__I_104038_i_F_104261 + N_102383__I_104038_i_F_104234 => N_102383__I_104038_i_F_104267 + N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104252 + N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104246 + N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104252 + N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104264 + N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104273 + !(N_102383__I_104038_i_F_104237 & N_102383__I_104038_i_F_104267) + N_102383__I_102808_i_F_102851 => N_102383__I_102808_i_F_102863 + N_102383__I_102808_i_F_102851 => N_102383__I_102808_i_F_102872 + N_102383__I_102808_i_F_102854 => N_102383__I_102808_i_F_102866 + N_102383__I_102808_i_F_102854 => N_102383__I_102808_i_F_102875 + N_102383__I_102808_i_F_102857 => N_102383__I_102808_i_F_102866 + N_102383__I_102808_i_F_102857 => N_102383__I_102808_i_F_102875 + N_102383__I_102808_i_F_102920 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_102920 => N_102383__I_102808_i_F_102935 + N_102383__I_102808_i_F_102920 => N_102383__I_102808_i_F_102950 + N_102383__I_102808_i_F_102923 => N_102383__I_102808_i_F_102935 + N_102383__I_102808_i_F_102923 => N_102383__I_102808_i_F_102950 + N_102383__I_102808_i_F_102923 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_102926 => N_102383__I_102808_i_F_102989 + N_102383__I_102808_i_F_102926 => N_102383__I_102808_i_F_102938 + N_102383__I_102808_i_F_102926 => N_102383__I_102808_i_F_102953 + N_102383__I_102808_i_F_102929 => N_102383__I_102808_i_F_102944 + N_102383__I_102808_i_F_102929 => N_102383__I_102808_i_F_102956 + N_102383__I_102808_i_F_102929 => N_102383__I_102808_i_F_102992 + N_102383__I_103054_i_F_103097 => N_102383__I_103054_i_F_103109 + N_102383__I_103054_i_F_103097 => N_102383__I_103054_i_F_103118 + N_102383__I_103054_i_F_103100 => N_102383__I_103054_i_F_103112 + N_102383__I_103054_i_F_103100 => N_102383__I_103054_i_F_103121 + N_102383__I_103054_i_F_103103 => N_102383__I_103054_i_F_103112 + N_102383__I_103054_i_F_103103 => N_102383__I_103054_i_F_103121 + N_102383__I_103054_i_F_103166 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103166 => N_102383__I_103054_i_F_103181 + N_102383__I_103054_i_F_103166 => N_102383__I_103054_i_F_103196 + N_102383__I_103054_i_F_103169 => N_102383__I_103054_i_F_103181 + N_102383__I_103054_i_F_103169 => N_102383__I_103054_i_F_103196 + N_102383__I_103054_i_F_103169 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103172 => N_102383__I_103054_i_F_103235 + N_102383__I_103054_i_F_103172 => N_102383__I_103054_i_F_103184 + N_102383__I_103054_i_F_103172 => N_102383__I_103054_i_F_103199 + N_102383__I_103054_i_F_103175 => N_102383__I_103054_i_F_103190 + N_102383__I_103054_i_F_103175 => N_102383__I_103054_i_F_103202 + N_102383__I_103054_i_F_103175 => N_102383__I_103054_i_F_103238 \ No newline at end of file diff --git a/test2.uvl b/test2.uvl new file mode 100644 index 0000000..65bb8e0 --- /dev/null +++ b/test2.uvl @@ -0,0 +1,10 @@ +features + x + optional + a + b + c + d + e +constraints + a | b | c | d => e \ No newline at end of file diff --git a/test_composedModel.uvl b/test_composedModel.uvl new file mode 100644 index 0000000..7ce77e9 --- /dev/null +++ b/test_composedModel.uvl @@ -0,0 +1,21 @@ +namespace Server + +features + Server {abstract true} + mandatory + FileSystem + or + NTFS + APFS + EXT4 + OperatingSystem {abstract true} + alternative + Windows + macOS + Debian + optional + Logging {log_level 2, default true} + +constraints + Windows => NTFS + macOS => APFS diff --git a/test_singleModel.uvl b/test_singleModel.uvl new file mode 100644 index 0000000..7ce77e9 --- /dev/null +++ b/test_singleModel.uvl @@ -0,0 +1,21 @@ +namespace Server + +features + Server {abstract true} + mandatory + FileSystem + or + NTFS + APFS + EXT4 + OperatingSystem {abstract true} + alternative + Windows + macOS + Debian + optional + Logging {log_level 2, default true} + +constraints + Windows => NTFS + macOS => APFS From 87f81c98e51cf7074ceb9e736e80b9bbb96213ad Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 19 Sep 2024 13:23:14 +0200 Subject: [PATCH 05/60] fix: fixed wrong constraint encoding --- .../java/de/vill/model/constraint/AndConstraint.java | 11 ++++++----- .../vill/model/constraint/EquivalenceConstraint.java | 11 ++++++----- .../vill/model/constraint/ImplicationConstraint.java | 11 ++++++----- .../java/de/vill/model/constraint/OrConstraint.java | 9 +++++---- 4 files changed, 23 insertions(+), 19 deletions(-) diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index ccdb57e..7efd3f8 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -82,10 +82,12 @@ public int extractTseitinSubConstraints(Map substitutionMap int a1 = 0; if(!isJustAnd(left) ){ a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); + n += a1; } int a2 = 0; if(!isJustAnd(right)){ - a2 = right.extractTseitinSubConstraints(substitutionMapping, n, counter); + a2 = right.extractTseitinSubConstraints(substitutionMapping, n + 1, counter); + n+= a2; } int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @@ -103,13 +105,12 @@ public String getIdentifier() { }); if(a1 == 0) { l1 = left; - }else{ - n = a1 + 1; } if(a2 == 0) { l2 = right; - }else{ - n = a2 + 1; + } + if (a1 + a2 != 0){ + n++; } Constraint newConstraint = new AndConstraint(l1, l2); diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index eca7899..3666736 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -81,7 +81,9 @@ public List getReferences() { public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { int a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); - int a2 = right.extractTseitinSubConstraints(substitutionMapping, a1+1, counter); + n = n+a1; + int a2 = right.extractTseitinSubConstraints(substitutionMapping, n+1, counter); + n = n + a2; int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @@ -99,13 +101,12 @@ public String getIdentifier() { }); if(a1 == 0) { l1 = left; - }else{ - n = a1 + 1; } if(a2 == 0) { l2 = right; - }else{ - n = a2 + 1; + } + if (a1 + a2 != 0){ + n++; } Constraint newConstraint = new EquivalenceConstraint(l1, l2); diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index aa104bc..cbc6ae2 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -81,7 +81,9 @@ public List getReferences() { public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { int a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); - int a2 = right.extractTseitinSubConstraints(substitutionMapping, a1+1, counter); + n += a1; + int a2 = right.extractTseitinSubConstraints(substitutionMapping, n+1, counter); + n+= a2; int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @Override @@ -98,13 +100,12 @@ public String getIdentifier() { }); if(a1 == 0) { l1 = left; - }else{ - n = a1 + 1; } if(a2 == 0) { l2 = right; - }else{ - n = a2 + 1; + } + if (a1 + a2 != 0){ + n++; } Constraint newConstraint = new ImplicationConstraint(l1, l2); diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index b623d96..4ba671e 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -83,10 +83,12 @@ public int extractTseitinSubConstraints(Map substitutionMap int a1 = 0; if(!isJustOr(left)){ a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); + n+= a1; } int a2 = 0; if(!isJustOr(right)){ a2 = right.extractTseitinSubConstraints(substitutionMapping, n, counter); + n += a2; } int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { @@ -104,13 +106,12 @@ public String getIdentifier() { }); if(a1 == 0) { l1 = left; - }else{ - n = a1 + 1; } if(a2 == 0) { l2 = right; - }else{ - n = a2 + 1; + } + if (a1 + a2 != 0){ + n++; } Constraint newConstraint = new OrConstraint(l1, l2); From dfca14c6d96b89295b61e009471b494fee492753 Mon Sep 17 00:00:00 2001 From: Stefan Date: Wed, 16 Oct 2024 12:42:27 +0200 Subject: [PATCH 06/60] fix: fixed wrong constraint encoding --- src/main/java/de/vill/util/Util.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 5052b1f..f972d11 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -314,8 +314,8 @@ public static List transformBiImplication(EquivalenceConstraint c PBCConstraint pbcConstraint2 = new PBCConstraint(); pbcConstraint2.k = 1; pbcConstraint2.literalList = new LinkedList<>(); - pbcConstraint2.literalList.add(l1); - pbcConstraint2.literalList.add(l2); + pbcConstraint2.literalList.add(l1_1); + pbcConstraint2.literalList.add(l2_1); List constraintList = new LinkedList<>(); constraintList.add(pbcConstraint1); constraintList.add(pbcConstraint2); From 59960921225825d79894534ac2e0016446535317 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 17 Oct 2024 16:39:43 +0200 Subject: [PATCH 07/60] fix: error in group cardinality conversion and multi or for larger possible group cardinality conversions --- .../conversion/ConvertGroupCardinality.java | 9 +- .../model/constraint/MultiOrConstraint.java | 110 ++++++++++++++++++ 2 files changed, 118 insertions(+), 1 deletion(-) create mode 100644 src/main/java/de/vill/model/constraint/MultiOrConstraint.java diff --git a/src/main/java/de/vill/conversion/ConvertGroupCardinality.java b/src/main/java/de/vill/conversion/ConvertGroupCardinality.java index a431b12..c5e88b1 100644 --- a/src/main/java/de/vill/conversion/ConvertGroupCardinality.java +++ b/src/main/java/de/vill/conversion/ConvertGroupCardinality.java @@ -47,7 +47,7 @@ private void removeGroupCardinality(Group group, FeatureModel featureModel) { Set groupMembers = new HashSet<>(group.getFeatures()); int lowerBound = group.getCardinality().lower; - int upperBound = Math.max(group.getCardinality().upper, groupMembers.size()); + int upperBound = Math.min(group.getCardinality().upper, groupMembers.size()); Set> featureCombinations = new HashSet<>(); for (int i = lowerBound; i <= upperBound; i++) { featureCombinations.addAll(Sets.combinations(groupMembers, i)); @@ -81,6 +81,11 @@ private Constraint createConjunction(Set selectedFeatures, Set } private Constraint createDisjunction(Set constraints) { + MultiOrConstraint orConstraint = new MultiOrConstraint(); + for (Constraint constraint : constraints) { + orConstraint.add_sub_part(constraint); + } + /* Constraint orConstraint; if (constraints.size() == 1) { Constraint constraint = constraints.iterator().next(); @@ -92,6 +97,8 @@ private Constraint createDisjunction(Set constraints) { orConstraint = new OrConstraint(constraint, createDisjunction(constraints)); } + */ + return orConstraint; } } diff --git a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java new file mode 100644 index 0000000..b7e3f61 --- /dev/null +++ b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java @@ -0,0 +1,110 @@ +package de.vill.model.constraint; + +import de.vill.model.building.VariableReference; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.Objects; + +public class MultiOrConstraint extends Constraint{ + + private List sub_parts; + + public MultiOrConstraint() { + sub_parts = new LinkedList<>(); + } + + @Override + public String toString(boolean withSubmodels, String currentAlias) { + StringBuilder result = new StringBuilder(); + for (Constraint part : sub_parts) { + result.append(part.toString(withSubmodels, currentAlias)); + result.append(" | "); + } + result.delete(result.length() -3, result.length()); + return result.toString(); + } + + @Override + public List getConstraintSubParts() { + return sub_parts; + } + + public void add_sub_part(Constraint constraint) { + sub_parts.add(constraint); + } + + @Override + public void replaceConstraintSubPart(Constraint oldSubConstraint, Constraint newSubConstraint) { + for (int i=0;i getReferences() { + List references = new ArrayList<>(); + for (int i=0;i Date: Thu, 17 Oct 2024 16:40:51 +0200 Subject: [PATCH 08/60] feat: printing fm to z3 input format --- src/main/java/de/vill/model/FeatureModel.java | 23 ++++++ src/main/java/de/vill/model/Group.java | 73 +++++++++++++++++++ .../vill/model/constraint/AndConstraint.java | 15 +++- .../de/vill/model/constraint/Constraint.java | 2 + .../constraint/EquivalenceConstraint.java | 11 +++ .../constraint/ExpressionConstraint.java | 5 ++ .../constraint/ImplicationConstraint.java | 11 +++ .../model/constraint/LiteralConstraint.java | 7 ++ .../vill/model/constraint/NotConstraint.java | 10 +++ .../vill/model/constraint/OrConstraint.java | 11 +++ .../constraint/ParenthesisConstraint.java | 7 ++ 11 files changed, 174 insertions(+), 1 deletion(-) diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 8eb9cfa..796fa9f 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -274,6 +274,29 @@ public String toOPBString(){ return result; } + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + builder.append("(set-logic QF_UF)\n"); + for (String name : this.getFeatureMap().keySet()) { + builder.append("(declare-const "); + builder.append(name); + builder.append(" Bool)\n"); + } + builder.append("(assert \n"); + builder.append(rootFeature.getFeatureName()); + builder.append(")\n"); + for (Group group : rootFeature.getChildren()){ + builder.append(group.toSMT2string()); + } + for (Constraint constraint : this.getConstraints()) { + builder.append("(assert \n"); + builder.append(constraint.toSMT2string()); + builder.append(")\n"); + } + builder.append("(apply tseitin-cnf)"); + return builder; + } + /** * Returns a single uvl feature model composed out of all submodels. To avoid * naming conflicts all feature names are changed and a unique id is added. If diff --git a/src/main/java/de/vill/model/Group.java b/src/main/java/de/vill/model/Group.java index 1597f27..cb00c1f 100644 --- a/src/main/java/de/vill/model/Group.java +++ b/src/main/java/de/vill/model/Group.java @@ -7,6 +7,7 @@ import java.util.Objects; import de.vill.config.Configuration; +import de.vill.model.constraint.Constraint; import de.vill.util.Util; /** @@ -28,6 +29,78 @@ public enum GroupType { private Cardinality cardinality; private Feature parent; + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + + builder.append("(assert \n"); + switch (GROUPTYPE) { + case OR: + builder.append("(= \n"); + builder.append(parent.getFeatureName()); + builder.append("\n(or\n"); + for (Feature feature : features) { + builder.append(feature.getFeatureName()); + builder.append("\n"); + } + + builder.append("))\n"); + break; + case ALTERNATIVE: + builder.append("(and \n"); + builder.append("(= \n"); + builder.append(parent.getFeatureName()); + builder.append("\n(or\n"); + for (Feature feature : features) { + builder.append(feature.getFeatureName()); + builder.append("\n"); + } + + builder.append("))\n"); + for (int i=0;i "); + builder.append(feature.getFeatureName()); + builder.append(" "); + builder.append(parent.getFeatureName()); + builder.append(")\n"); + } + builder.append(")\n"); + break; + case MANDATORY: + builder.append("(and\n"); + for (Feature feature : features) { + builder.append("(= "); + builder.append(feature.getFeatureName()); + builder.append(" "); + builder.append(parent.getFeatureName()); + builder.append(")\n"); + } + builder.append(")\n"); + break; + } + builder.append(")\n"); + for (Feature feature : features) { + for (Group group : feature.getChildren()) { + builder.append(group.toSMT2string()); + } + } + return builder; + } + /** * The constructor of the group class. * diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index 7efd3f8..0aec80c 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -116,5 +116,18 @@ public String getIdentifier() { Constraint newConstraint = new AndConstraint(l1, l2); substitutionMapping.put(n, newConstraint); return n; - }; + } + + @Override + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + builder.append("(and\n"); + builder.append(left.toSMT2string()); + builder.append("\n"); + builder.append(right.toSMT2string()); + builder.append(")"); + return builder; + } + + ; } diff --git a/src/main/java/de/vill/model/constraint/Constraint.java b/src/main/java/de/vill/model/constraint/Constraint.java index 366c7c8..5acffbb 100644 --- a/src/main/java/de/vill/model/constraint/Constraint.java +++ b/src/main/java/de/vill/model/constraint/Constraint.java @@ -45,4 +45,6 @@ public int hashCode() { public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { return 0; }; + + public abstract StringBuilder toSMT2string(); } diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index 3666736..8322a36 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -114,4 +114,15 @@ public String getIdentifier() { return n; }; + @Override + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + builder.append("(<=>\n"); + builder.append(left.toSMT2string()); + builder.append("\n"); + builder.append(right.toSMT2string()); + builder.append(")"); + return builder; + } + } diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index f8213be..5793454 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -111,4 +111,9 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } + + @Override + public StringBuilder toSMT2string() { + return null; + } } diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index cbc6ae2..8d4bb4b 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -112,4 +112,15 @@ public String getIdentifier() { substitutionMapping.put(n, newConstraint); return n; }; + + @Override + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + builder.append("(=>\n"); + builder.append(left.toSMT2string()); + builder.append("\n"); + builder.append(right.toSMT2string()); + builder.append(")"); + return builder; + } } diff --git a/src/main/java/de/vill/model/constraint/LiteralConstraint.java b/src/main/java/de/vill/model/constraint/LiteralConstraint.java index 12ab542..138e206 100644 --- a/src/main/java/de/vill/model/constraint/LiteralConstraint.java +++ b/src/main/java/de/vill/model/constraint/LiteralConstraint.java @@ -61,4 +61,11 @@ public boolean equals(Object obj) { public List getReferences() { return List.of(reference); } + + @Override + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + builder.append(reference.getIdentifier()); + return builder; + } } diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index e7439e3..c9e1427 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -93,4 +93,14 @@ public String getIdentifier() { substitutionMapping.put(n, newConstraint); return n; }; + + @Override + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + builder.append("(not\n"); + builder.append(content.toSMT2string()); + builder.append("\n"); + builder.append(")"); + return builder; + } } diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index 4ba671e..003df0c 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -118,4 +118,15 @@ public String getIdentifier() { substitutionMapping.put(n, newConstraint); return n; }; + + @Override + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + builder.append("(or\n"); + builder.append(left.toSMT2string()); + builder.append("\n"); + builder.append(right.toSMT2string()); + builder.append(")"); + return builder; + } } diff --git a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java index 27b72fa..73c55c7 100644 --- a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java +++ b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java @@ -67,4 +67,11 @@ public List getReferences() { public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { return content.extractTseitinSubConstraints(substitutionMapping, n, counter); }; + + @Override + public StringBuilder toSMT2string() { + StringBuilder builder = new StringBuilder(); + builder.append(content.toSMT2string()); + return builder; + } } From df1afaebd209c9af9a127dc1fa1d13a582e6fa21 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 17 Oct 2024 16:42:48 +0200 Subject: [PATCH 09/60] feat: uvl to opb and dimacs pipeline --- src/main/java/de/vill/main/Eval.java | 86 ++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 src/main/java/de/vill/main/Eval.java diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java new file mode 100644 index 0000000..621f4e3 --- /dev/null +++ b/src/main/java/de/vill/main/Eval.java @@ -0,0 +1,86 @@ +package de.vill.main; + +import de.vill.model.FeatureModel; +import de.vill.model.LanguageLevel; +import de.vill.model.constraint.Constraint; + +import java.io.*; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Set; + +import static de.vill.util.Util.transformSubFormulas; + +public class Eval { + + public static final String WORKING_DIR = "/home/stefan/eval/"; + + public static void main(String[] args) throws IOException { + uvlToOPB("test"); + uvlToDimacs("test"); + } + + public static void uvlToOPB(String modelName) throws IOException { + UVLModelFactory uvlModelFactory = new UVLModelFactory(); + FeatureModel featureModel = loadUVLFeatureModelFromFile(WORKING_DIR + modelName + ".uvl"); + try (BufferedWriter writer = new BufferedWriter(new FileWriter(WORKING_DIR + "test.opb"))) { + writer.append(featureModel.toOPBString()); + writer.flush(); + } catch (IOException e) { + System.err.println("Error writing to file: " + e.getMessage()); + } + } + + public static void uvlToDimacs(String modelName) throws IOException { + uvlToSMT2(modelName + ".uvl", modelName + ".smt2"); + smt2ToDimacs(modelName + ".smt2", modelName + ".dimacs"); + } + + public static void smt2ToDimacs(String smt2Path, String dimacsPath) throws IOException { + ProcessBuilder processBuilder = new ProcessBuilder(); + processBuilder.command("python3", WORKING_DIR + "smt2ToDimacs.py", WORKING_DIR + smt2Path, WORKING_DIR + dimacsPath); + + try { + // Start the process + Process process = processBuilder.start(); + // Read the output from the process + BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); + String line; + while ((line = reader.readLine()) != null) { + System.out.println(line); + } + + // Wait for the process to complete and get the exit value + int exitCode = process.waitFor(); + System.out.println("Process exited with code: " + exitCode); + } catch (IOException | InterruptedException e) { + e.printStackTrace(); + } + } + + public static void uvlToSMT2(String uvlPath, String dimacsPath) throws IOException { + UVLModelFactory uvlModelFactory = new UVLModelFactory(); + FeatureModel featureModel = loadUVLFeatureModelFromFile(WORKING_DIR + uvlPath); + Set levels = new HashSet<>(); + levels.add(LanguageLevel.BOOLEAN_LEVEL); + uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); + + try (BufferedWriter writer = new BufferedWriter(new FileWriter(WORKING_DIR + "test.smt2"))) { + writer.append(featureModel.toSMT2string()); + writer.flush(); + } catch (IOException e) { + System.err.println("Error writing to file: " + e.getMessage()); + } + } + + private static FeatureModel loadUVLFeatureModelFromFile(String path) throws IOException { + Path filePath = Paths.get(path); + String content = new String(Files.readAllBytes(filePath)); + UVLModelFactory uvlModelFactory = new UVLModelFactory(); + FeatureModel featureModel = uvlModelFactory.parse(content); + return featureModel; + } +} From 3144252d1808779f5f33ea4ffac7aec2ada41632 Mon Sep 17 00:00:00 2001 From: Stefan Date: Tue, 22 Oct 2024 10:05:39 +0200 Subject: [PATCH 10/60] fix: only include satisfying assignments for an ExpressionsConstraint during conversion strategy --- .../model/expression/LiteralExpression.java | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/src/main/java/de/vill/model/expression/LiteralExpression.java b/src/main/java/de/vill/model/expression/LiteralExpression.java index a20a372..f59889d 100644 --- a/src/main/java/de/vill/model/expression/LiteralExpression.java +++ b/src/main/java/de/vill/model/expression/LiteralExpression.java @@ -79,14 +79,18 @@ public double evaluate(final Set selectedFeatures) { return 0d; } else { Attribute attribute = (Attribute) content; - final Object attributeValue = attribute.getValue(); - if (attributeValue instanceof Integer) { - return ((Integer) attributeValue).doubleValue(); + if (selectedFeatures.contains(attribute.getFeature())) { + final Object attributeValue = attribute.getValue(); + if (attributeValue instanceof Integer) { + return ((Integer) attributeValue).doubleValue(); + } + if (attributeValue instanceof Long) { + return ((Long) attributeValue).doubleValue(); + } + return (double) attributeValue; + }else { + return 0; } - if (attributeValue instanceof Long) { - return ((Long) attributeValue).doubleValue(); - } - return (double) attributeValue; } } From 1d9058fab5da639b7853cca7210eea69b7414ce4 Mon Sep 17 00:00:00 2001 From: Stefan Date: Tue, 22 Oct 2024 10:07:59 +0200 Subject: [PATCH 11/60] fix: also include feature constraints for pseudo-boolean encoding --- src/main/java/de/vill/model/FeatureModel.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 796fa9f..37e0f60 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -260,7 +260,11 @@ public String toOPBString(){ result += getRootFeature().getFeatureName().replace(" ", "_") + " >= 1;\n"; result += getRootFeature().toOPBString(); int counter = 0; - for(Constraint constraint : getConstraints()){ + + List constraints = getConstraints(); + constraints.addAll(getFeatureConstraints()); + + for(Constraint constraint : constraints){ HashMap subMap = new HashMap<>(); int n = 1; constraint.extractTseitinSubConstraints(subMap, n, counter); From a21f1f31d6d147385ac03213e1b3c13222369cac Mon Sep 17 00:00:00 2001 From: Stefan Date: Tue, 22 Oct 2024 15:39:57 +0200 Subject: [PATCH 12/60] feat: pseudo boolean encoding of feature attribute constraints without division --- src/main/java/de/vill/main/Eval.java | 3 +- src/main/java/de/vill/main/Example.java | 16 ++++--- src/main/java/de/vill/model/FeatureModel.java | 9 +++- .../de/vill/model/constraint/Constraint.java | 11 +++++ .../constraint/ExpressionConstraint.java | 23 ++++++++++ .../vill/model/expression/AddExpression.java | 11 +++++ .../AggregateFunctionExpression.java | 7 ++++ .../vill/model/expression/DivExpression.java | 8 ++++ .../de/vill/model/expression/Expression.java | 4 ++ .../LengthAggregateFunctionExpression.java | 7 ++++ .../model/expression/LiteralExpression.java | 19 +++++++-- .../vill/model/expression/MulExpression.java | 42 ++++++++++++++++++- .../model/expression/NumberExpression.java | 9 ++++ .../expression/ParenthesisExpression.java | 7 ++++ .../model/expression/StringExpression.java | 7 ++++ .../vill/model/expression/SubExpression.java | 12 ++++++ src/main/java/de/vill/model/pbc/Literal.java | 5 +++ .../vill/util/SubstitutionVariableIndex.java | 21 ++++++++++ src/main/java/de/vill/util/Util.java | 42 +++++++++++++++++-- 19 files changed, 247 insertions(+), 16 deletions(-) create mode 100644 src/main/java/de/vill/util/SubstitutionVariableIndex.java diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index 621f4e3..9cca526 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -16,7 +16,7 @@ public class Eval { - public static final String WORKING_DIR = "/home/stefan/eval/"; + public static final String WORKING_DIR = "/home/stefan/stefan-vill-master/tmp_eval/"; public static void main(String[] args) throws IOException { uvlToOPB("test"); @@ -66,6 +66,7 @@ public static void uvlToSMT2(String uvlPath, String dimacsPath) throws IOExcepti FeatureModel featureModel = loadUVLFeatureModelFromFile(WORKING_DIR + uvlPath); Set levels = new HashSet<>(); levels.add(LanguageLevel.BOOLEAN_LEVEL); + levels.add(LanguageLevel.TYPE_LEVEL); uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); try (BufferedWriter writer = new BufferedWriter(new FileWriter(WORKING_DIR + "test.smt2"))) { diff --git a/src/main/java/de/vill/main/Example.java b/src/main/java/de/vill/main/Example.java index 66089c3..e217870 100644 --- a/src/main/java/de/vill/main/Example.java +++ b/src/main/java/de/vill/main/Example.java @@ -20,14 +20,20 @@ public static void main(String[] args) throws IOException { FeatureModel featureModel = loadUVLFeatureModelFromFile("test.uvl"); UVLModelFactory uvlModelFactory = new UVLModelFactory(); - System.out.println(featureModel.toOPBString()); + //System.out.println(featureModel.toOPBString()); + + + + Set levels = new HashSet<>(); + levels.add(LanguageLevel.BOOLEAN_LEVEL); + levels.add( LanguageLevel.TYPE_LEVEL); + uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); + System.out.println(featureModel.composedModelToString()); + + - //Set levels = new HashSet<>(); - //levels.add(LanguageLevel.BOOLEAN_LEVEL); - //uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); - //System.out.println(featureModel.composedModelToString()); /* diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 37e0f60..268f855 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -11,6 +11,7 @@ import de.vill.config.Configuration; import de.vill.model.constraint.Constraint; +import de.vill.model.constraint.ExpressionConstraint; import de.vill.model.constraint.LiteralConstraint; import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; @@ -264,17 +265,23 @@ public String toOPBString(){ List constraints = getConstraints(); constraints.addAll(getFeatureConstraints()); + List additionalConstraints = new LinkedList<>(); + for(Constraint constraint : constraints){ HashMap subMap = new HashMap<>(); int n = 1; constraint.extractTseitinSubConstraints(subMap, n, counter); - var map = transformSubFormulas(subMap); + var map = transformSubFormulas(subMap, additionalConstraints); List pbcList = transformImplicationMap(map, counter); for(PBCConstraint pbcConstraint : pbcList){ result += pbcConstraint.toString() + ";\n"; } counter++; } + + for (PBCConstraint pbcConstraint : additionalConstraints){ + result += pbcConstraint.toString() + ";\n"; + } return result; } diff --git a/src/main/java/de/vill/model/constraint/Constraint.java b/src/main/java/de/vill/model/constraint/Constraint.java index 5acffbb..0a99aa9 100644 --- a/src/main/java/de/vill/model/constraint/Constraint.java +++ b/src/main/java/de/vill/model/constraint/Constraint.java @@ -1,7 +1,9 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import java.util.LinkedList; import java.util.List; import java.util.Map; @@ -47,4 +49,13 @@ public int extractTseitinSubConstraints(Map substitutionMap }; public abstract StringBuilder toSMT2string(); + + public List collectExpressions(){ + List expressions = new LinkedList<>(); + for (Constraint subConstraint : getConstraintSubParts()) { + expressions.addAll(subConstraint.collectExpressions()); + } + return expressions; + } } + diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index 5793454..dfdc76c 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -5,6 +5,7 @@ import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; import de.vill.model.expression.LiteralExpression; +import de.vill.model.pbc.Literal; import java.util.*; @@ -116,4 +117,26 @@ public List getReferences() { public StringBuilder toSMT2string() { return null; } + + @Override + public List collectExpressions(){ + List expressions = new LinkedList<>(); + expressions.add(this); + return expressions; + } + + @Override + public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { + final int finalN = n; + Constraint l1 = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + counter + "_" + finalN; + } + }); + n++; + + substitutionMapping.put(n, this); + return n; + } } diff --git a/src/main/java/de/vill/model/expression/AddExpression.java b/src/main/java/de/vill/model/expression/AddExpression.java index 82dee3f..6c52379 100644 --- a/src/main/java/de/vill/model/expression/AddExpression.java +++ b/src/main/java/de/vill/model/expression/AddExpression.java @@ -2,6 +2,8 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; import java.util.*; @@ -83,4 +85,13 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } + + @Override + public List getAsSum(List additionalConstraints) { + List result = new LinkedList<>(); + result.addAll(left.getAsSum(additionalConstraints)); + List rightSum = right.getAsSum(additionalConstraints); + result.addAll(rightSum); + return result; + } } diff --git a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java index a75fb30..c36d99e 100644 --- a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java @@ -6,6 +6,8 @@ import de.vill.model.Feature; import de.vill.model.GlobalAttribute; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; import java.util.Arrays; import java.util.List; @@ -114,4 +116,9 @@ public boolean equals(Object obj) { public List getReferences() { return List.of(attribute); } + + @Override + public List getAsSum(List additionalConstraints) { + throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); + } } diff --git a/src/main/java/de/vill/model/expression/DivExpression.java b/src/main/java/de/vill/model/expression/DivExpression.java index 1449e02..a7506d7 100644 --- a/src/main/java/de/vill/model/expression/DivExpression.java +++ b/src/main/java/de/vill/model/expression/DivExpression.java @@ -2,7 +2,10 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; +import jdk.jshell.spi.ExecutionControl; import java.util.*; @@ -83,4 +86,9 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } + + @Override + public List getAsSum(List additionalConstraints) { + throw new UnsupportedOperationException("All DivExpressions must be removed before method is called."); + } } diff --git a/src/main/java/de/vill/model/expression/Expression.java b/src/main/java/de/vill/model/expression/Expression.java index 382e506..a9886ec 100644 --- a/src/main/java/de/vill/model/expression/Expression.java +++ b/src/main/java/de/vill/model/expression/Expression.java @@ -2,6 +2,8 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import java.util.List; import java.util.Set; @@ -43,4 +45,6 @@ public int hashCode() { public abstract boolean equals(Object obj); public abstract List getReferences(); + + public abstract List getAsSum(List additionalConstraints); } diff --git a/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java index 14e4336..27fa6c0 100644 --- a/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java @@ -4,6 +4,8 @@ import de.vill.model.Attribute; import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; import de.vill.util.Util; @@ -88,4 +90,9 @@ public boolean equals(Object obj) { public List getReferences() { return List.of(); } + + @Override + public List getAsSum(List additionalConstraints) { + throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); + } } diff --git a/src/main/java/de/vill/model/expression/LiteralExpression.java b/src/main/java/de/vill/model/expression/LiteralExpression.java index f59889d..7de1ccb 100644 --- a/src/main/java/de/vill/model/expression/LiteralExpression.java +++ b/src/main/java/de/vill/model/expression/LiteralExpression.java @@ -4,13 +4,12 @@ import de.vill.model.Feature; import de.vill.model.FeatureType; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; import de.vill.util.Util; -import java.util.Collections; -import java.util.List; -import java.util.Objects; -import java.util.Set; +import java.util.*; public class LiteralExpression extends Expression { private VariableReference content; @@ -125,4 +124,16 @@ public List getReferences() { return List.of(content); } + @Override + public List getAsSum(List additionalConstraints) { + Literal l = new Literal(); + //TODO handle more than just Long attributes + var attribute = (Attribute)getContent(); + l.name = attribute.getFeature().getFeatureName(); + l.factor = Math.toIntExact((attribute.getValue())); + List result = new LinkedList<>(); + result.add(l); + return result; + } + } diff --git a/src/main/java/de/vill/model/expression/MulExpression.java b/src/main/java/de/vill/model/expression/MulExpression.java index 9a02fe5..804ee93 100644 --- a/src/main/java/de/vill/model/expression/MulExpression.java +++ b/src/main/java/de/vill/model/expression/MulExpression.java @@ -2,7 +2,10 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; +import de.vill.util.SubstitutionVariableIndex; import java.util.*; @@ -62,7 +65,7 @@ public double evaluate(Set selectedFeatures) { } else { rightResult = right.evaluate(selectedFeatures); } - return leftResult + rightResult; + return leftResult * rightResult; } @Override @@ -93,6 +96,43 @@ public List getReferences() { return references; } + @Override + public List getAsSum(List additionalConstraints) { + var leftSum = left.getAsSum(additionalConstraints); + var rightSum = right.getAsSum(additionalConstraints); + List result = new LinkedList<>(); + SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); + for (int i=0;i getSubstitutionConstraints(String a, String b, String c){ + List result = new LinkedList<>(); + PBCConstraint pbcConstraint1 = new PBCConstraint(); + pbcConstraint1.literalList = new LinkedList<>(); + pbcConstraint1.k = 0; + pbcConstraint1.literalList.add(new Literal(1, a)); + pbcConstraint1.literalList.add(new Literal(1, b)); + pbcConstraint1.literalList.add(new Literal(-2, c)); + result.add(pbcConstraint1); + PBCConstraint pbcConstraint2 = new PBCConstraint(); + pbcConstraint2.literalList = new LinkedList<>(); + pbcConstraint2.k = -1; + pbcConstraint2.literalList.add(new Literal(-1, a)); + pbcConstraint2.literalList.add(new Literal(-1, b)); + pbcConstraint2.literalList.add(new Literal(2, c)); + result.add(pbcConstraint2); + return result; + } + @Override public String getReturnType() { return Constants.NUMBER; diff --git a/src/main/java/de/vill/model/expression/NumberExpression.java b/src/main/java/de/vill/model/expression/NumberExpression.java index fddc60c..e0215c9 100644 --- a/src/main/java/de/vill/model/expression/NumberExpression.java +++ b/src/main/java/de/vill/model/expression/NumberExpression.java @@ -2,6 +2,8 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; import java.util.*; @@ -82,6 +84,13 @@ public List getReferences() { return new ArrayList<>(); } + @Override + public List getAsSum(List additionalConstraints) { + List result = new LinkedList<>(); + result.add(new Literal((int) number, null)); + return result; + } + @Override public String getReturnType() { return Constants.NUMBER; diff --git a/src/main/java/de/vill/model/expression/ParenthesisExpression.java b/src/main/java/de/vill/model/expression/ParenthesisExpression.java index 1a78757..1492808 100644 --- a/src/main/java/de/vill/model/expression/ParenthesisExpression.java +++ b/src/main/java/de/vill/model/expression/ParenthesisExpression.java @@ -2,6 +2,8 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import java.util.Collections; import java.util.List; @@ -73,6 +75,11 @@ public List getReferences() { return List.of(); } + @Override + public List getAsSum(List additionalConstraints) { + return getContent().getAsSum(additionalConstraints); + } + @Override public String getReturnType() { return content.getReturnType(); diff --git a/src/main/java/de/vill/model/expression/StringExpression.java b/src/main/java/de/vill/model/expression/StringExpression.java index cf4b6cd..391d53b 100644 --- a/src/main/java/de/vill/model/expression/StringExpression.java +++ b/src/main/java/de/vill/model/expression/StringExpression.java @@ -2,6 +2,8 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; import java.util.*; @@ -79,6 +81,11 @@ public List getReferences() { return new ArrayList<>(); } + @Override + public List getAsSum(List additionalConstraints) { + throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); + } + @Override public String getReturnType() { return Constants.STRING; diff --git a/src/main/java/de/vill/model/expression/SubExpression.java b/src/main/java/de/vill/model/expression/SubExpression.java index cdcb298..d5382d8 100644 --- a/src/main/java/de/vill/model/expression/SubExpression.java +++ b/src/main/java/de/vill/model/expression/SubExpression.java @@ -2,6 +2,8 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCConstraint; import de.vill.util.Constants; import java.util.*; @@ -76,6 +78,16 @@ public List getReferences() { return result; } + public List getAsSum(List additionalConstraints) { + var result = left.getAsSum(additionalConstraints); + var rightResult = right.getAsSum(additionalConstraints); + for (Literal l : rightResult){ + l.factor *= -1; + } + result.addAll(rightResult); + return result; + } + @Override public String getReturnType() { return Constants.NUMBER; diff --git a/src/main/java/de/vill/model/pbc/Literal.java b/src/main/java/de/vill/model/pbc/Literal.java index 442f141..d899589 100644 --- a/src/main/java/de/vill/model/pbc/Literal.java +++ b/src/main/java/de/vill/model/pbc/Literal.java @@ -3,4 +3,9 @@ public class Literal { public String name; public int factor; + public Literal(){} + public Literal(int factor, String name) { + this.name = name; + this.factor = factor; + } } diff --git a/src/main/java/de/vill/util/SubstitutionVariableIndex.java b/src/main/java/de/vill/util/SubstitutionVariableIndex.java new file mode 100644 index 0000000..d7c67d7 --- /dev/null +++ b/src/main/java/de/vill/util/SubstitutionVariableIndex.java @@ -0,0 +1,21 @@ +package de.vill.util; + +public class SubstitutionVariableIndex { + private int index; + private static SubstitutionVariableIndex objectRef; + private SubstitutionVariableIndex() { + index = 0; + } + + public static SubstitutionVariableIndex getInstance() { + if (objectRef == null) { + objectRef = new SubstitutionVariableIndex(); + } + return objectRef; + } + + public String getIndex() { + index++; + return "sub_z_" + index; + } +} diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index f972d11..1bb2c5c 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -1,7 +1,9 @@ package de.vill.util; import de.vill.config.Configuration; +import de.vill.model.Attribute; import de.vill.model.constraint.*; +import de.vill.model.expression.*; import de.vill.model.pbc.Literal; import de.vill.model.pbc.PBCConstraint; @@ -12,6 +14,8 @@ import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.function.ToDoubleBiFunction; +import java.util.stream.Collectors; public class Util { public static String indentEachLine(String text) { @@ -144,15 +148,15 @@ public static List transformImplicationMap (HashMap> transformSubFormulas(HashMap subformulas){ + public static HashMap> transformSubFormulas(HashMap subformulas, List additionalConstraints){ HashMap> resultMap = new HashMap<>(); for (Map.Entry entry : subformulas.entrySet()) { - resultMap.put(entry.getKey(), transformSubFormula(entry.getValue())); + resultMap.put(entry.getKey(), transformSubFormula(entry.getValue(), additionalConstraints)); } return resultMap; } - public static List transformSubFormula(Constraint constraint){ + public static List transformSubFormula(Constraint constraint, List additionalConstraints){ List resultList = new LinkedList<>(); if(constraint instanceof NotConstraint){ resultList.add(transformNegLiteral((NotConstraint) constraint)); @@ -169,6 +173,10 @@ else if (constraint instanceof OrConstraint) { orConstraint.k = orConstraint.k + 1; resultList.add(orConstraint); } + else if (constraint instanceof ExpressionConstraint) { + ExpressionConstraint expressionConstraint = (ExpressionConstraint) constraint; + resultList.add(transformExpression(expressionConstraint, additionalConstraints)); + } return resultList; } @@ -401,5 +409,31 @@ public static PBCConstraint transformOr(Constraint constraint){ return pbcConstraint; } } - + + public static PBCConstraint transformExpression(ExpressionConstraint constraint, List additionalConstraints) { + //TODO constraint.removeDiv + var leftSum = constraint.getLeft().getAsSum(additionalConstraints); + var rightSum = constraint.getRight().getAsSum(additionalConstraints); + rightSum.addAll(leftSum.stream().filter(x -> x.name == null).collect(Collectors.toList())); + leftSum = leftSum.stream().filter(x -> x.name != null).collect(Collectors.toList()); + leftSum.addAll(rightSum.stream().filter(x -> x.name != null).collect(Collectors.toList())); + rightSum = rightSum.stream().filter(x -> x.name == null).collect(Collectors.toList()); + + HashMap literalMap = new HashMap<>(); + for (Literal l : leftSum) { + if (literalMap.containsKey(l.name)) { + literalMap.put(l.name, literalMap.get(l.name) + l.factor); + }else{ + literalMap.put(l.name, l.factor); + } + } + PBCConstraint pbcConstraint = new PBCConstraint(); + pbcConstraint.k = rightSum.stream().map(x -> x.factor).reduce(0, Integer::sum); + pbcConstraint.literalList = new LinkedList<>(); + for (Map.Entry e : literalMap.entrySet()) { + pbcConstraint.literalList.add(new Literal(e.getValue(), e.getKey())); + } + + return pbcConstraint; + } } From 073daa4e6978acacd9702dae5130a38f1f8d90ce Mon Sep 17 00:00:00 2001 From: Stefan Date: Wed, 23 Oct 2024 15:53:39 +0200 Subject: [PATCH 13/60] feat: pseudo boolean encoding of feature attribute constraints with division --- src/main/java/de/vill/model/FeatureModel.java | 15 +- .../constraint/ExpressionConstraint.java | 8 + .../vill/model/expression/AddExpression.java | 4 +- .../AggregateFunctionExpression.java | 5 +- .../vill/model/expression/DivExpression.java | 5 +- .../de/vill/model/expression/Expression.java | 4 +- .../LengthAggregateFunctionExpression.java | 6 +- .../model/expression/LiteralExpression.java | 4 +- .../vill/model/expression/MulExpression.java | 36 +- .../model/expression/NumberExpression.java | 4 +- .../expression/ParenthesisExpression.java | 4 +- .../model/expression/StringExpression.java | 4 +- .../vill/model/expression/SubExpression.java | 4 +- .../{PBCConstraint.java => PBConstraint.java} | 10 +- .../de/vill/model/pbc/PBConstraintType.java | 25 ++ src/main/java/de/vill/util/Util.java | 367 +++++++++++------- 16 files changed, 318 insertions(+), 187 deletions(-) rename src/main/java/de/vill/model/pbc/{PBCConstraint.java => PBConstraint.java} (71%) create mode 100644 src/main/java/de/vill/model/pbc/PBConstraintType.java diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 268f855..2280e12 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -11,12 +11,11 @@ import de.vill.config.Configuration; import de.vill.model.constraint.Constraint; -import de.vill.model.constraint.ExpressionConstraint; import de.vill.model.constraint.LiteralConstraint; import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; import de.vill.model.expression.LiteralExpression; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Util; import static de.vill.util.Util.*; @@ -265,22 +264,22 @@ public String toOPBString(){ List constraints = getConstraints(); constraints.addAll(getFeatureConstraints()); - List additionalConstraints = new LinkedList<>(); + List additionalConstraints = new LinkedList<>(); for(Constraint constraint : constraints){ HashMap subMap = new HashMap<>(); int n = 1; constraint.extractTseitinSubConstraints(subMap, n, counter); var map = transformSubFormulas(subMap, additionalConstraints); - List pbcList = transformImplicationMap(map, counter); - for(PBCConstraint pbcConstraint : pbcList){ - result += pbcConstraint.toString() + ";\n"; + List pbcList = transformImplicationMap(map, counter); + for(PBConstraint PBConstraint : pbcList){ + result += PBConstraint.toString() + ";\n"; } counter++; } - for (PBCConstraint pbcConstraint : additionalConstraints){ - result += pbcConstraint.toString() + ";\n"; + for (PBConstraint PBConstraint : additionalConstraints){ + result += PBConstraint.toString() + ";\n"; } return result; } diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index dfdc76c..018a2fb 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -28,6 +28,14 @@ public Expression getRight() { return right; } + public void setLeft(Expression expression) { + left = expression; + } + + public void setRight(Expression expression) { + right = expression; + } + public String getExpressionSymbol() { return expressionSymbol; } diff --git a/src/main/java/de/vill/model/expression/AddExpression.java b/src/main/java/de/vill/model/expression/AddExpression.java index 6c52379..b0ec73c 100644 --- a/src/main/java/de/vill/model/expression/AddExpression.java +++ b/src/main/java/de/vill/model/expression/AddExpression.java @@ -3,7 +3,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.*; @@ -87,7 +87,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { List result = new LinkedList<>(); result.addAll(left.getAsSum(additionalConstraints)); List rightSum = right.getAsSum(additionalConstraints); diff --git a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java index c36d99e..3833994 100644 --- a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java @@ -2,12 +2,11 @@ import static de.vill.util.Util.addNecessaryQuotes; -import de.vill.model.Attribute; import de.vill.model.Feature; import de.vill.model.GlobalAttribute; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.Arrays; import java.util.List; @@ -118,7 +117,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); } } diff --git a/src/main/java/de/vill/model/expression/DivExpression.java b/src/main/java/de/vill/model/expression/DivExpression.java index a7506d7..fcf6ecc 100644 --- a/src/main/java/de/vill/model/expression/DivExpression.java +++ b/src/main/java/de/vill/model/expression/DivExpression.java @@ -3,9 +3,8 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; -import jdk.jshell.spi.ExecutionControl; import java.util.*; @@ -88,7 +87,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { throw new UnsupportedOperationException("All DivExpressions must be removed before method is called."); } } diff --git a/src/main/java/de/vill/model/expression/Expression.java b/src/main/java/de/vill/model/expression/Expression.java index a9886ec..7d2719f 100644 --- a/src/main/java/de/vill/model/expression/Expression.java +++ b/src/main/java/de/vill/model/expression/Expression.java @@ -3,7 +3,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import java.util.List; import java.util.Set; @@ -46,5 +46,5 @@ public int hashCode() { public abstract List getReferences(); - public abstract List getAsSum(List additionalConstraints); + public abstract List getAsSum(List additionalConstraints); } diff --git a/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java index 27fa6c0..c9a31f0 100644 --- a/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java @@ -1,11 +1,9 @@ package de.vill.model.expression; -import com.google.errorprone.annotations.Var; -import de.vill.model.Attribute; import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import de.vill.util.Util; @@ -92,7 +90,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); } } diff --git a/src/main/java/de/vill/model/expression/LiteralExpression.java b/src/main/java/de/vill/model/expression/LiteralExpression.java index 7de1ccb..add364b 100644 --- a/src/main/java/de/vill/model/expression/LiteralExpression.java +++ b/src/main/java/de/vill/model/expression/LiteralExpression.java @@ -5,7 +5,7 @@ import de.vill.model.FeatureType; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import de.vill.util.Util; @@ -125,7 +125,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { Literal l = new Literal(); //TODO handle more than just Long attributes var attribute = (Attribute)getContent(); diff --git a/src/main/java/de/vill/model/expression/MulExpression.java b/src/main/java/de/vill/model/expression/MulExpression.java index 804ee93..7beef31 100644 --- a/src/main/java/de/vill/model/expression/MulExpression.java +++ b/src/main/java/de/vill/model/expression/MulExpression.java @@ -3,7 +3,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import de.vill.util.SubstitutionVariableIndex; @@ -97,7 +97,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { var leftSum = left.getAsSum(additionalConstraints); var rightSum = right.getAsSum(additionalConstraints); List result = new LinkedList<>(); @@ -114,22 +114,22 @@ public List getAsSum(List additionalConstraints) { return result; } - private List getSubstitutionConstraints(String a, String b, String c){ - List result = new LinkedList<>(); - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.k = 0; - pbcConstraint1.literalList.add(new Literal(1, a)); - pbcConstraint1.literalList.add(new Literal(1, b)); - pbcConstraint1.literalList.add(new Literal(-2, c)); - result.add(pbcConstraint1); - PBCConstraint pbcConstraint2 = new PBCConstraint(); - pbcConstraint2.literalList = new LinkedList<>(); - pbcConstraint2.k = -1; - pbcConstraint2.literalList.add(new Literal(-1, a)); - pbcConstraint2.literalList.add(new Literal(-1, b)); - pbcConstraint2.literalList.add(new Literal(2, c)); - result.add(pbcConstraint2); + private List getSubstitutionConstraints(String a, String b, String c){ + List result = new LinkedList<>(); + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.k = 0; + PBConstraint1.literalList.add(new Literal(1, a)); + PBConstraint1.literalList.add(new Literal(1, b)); + PBConstraint1.literalList.add(new Literal(-2, c)); + result.add(PBConstraint1); + PBConstraint PBConstraint2 = new PBConstraint(); + PBConstraint2.literalList = new LinkedList<>(); + PBConstraint2.k = -1; + PBConstraint2.literalList.add(new Literal(-1, a)); + PBConstraint2.literalList.add(new Literal(-1, b)); + PBConstraint2.literalList.add(new Literal(2, c)); + result.add(PBConstraint2); return result; } diff --git a/src/main/java/de/vill/model/expression/NumberExpression.java b/src/main/java/de/vill/model/expression/NumberExpression.java index e0215c9..9424a2e 100644 --- a/src/main/java/de/vill/model/expression/NumberExpression.java +++ b/src/main/java/de/vill/model/expression/NumberExpression.java @@ -3,7 +3,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.*; @@ -85,7 +85,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { List result = new LinkedList<>(); result.add(new Literal((int) number, null)); return result; diff --git a/src/main/java/de/vill/model/expression/ParenthesisExpression.java b/src/main/java/de/vill/model/expression/ParenthesisExpression.java index 1492808..7e02a2d 100644 --- a/src/main/java/de/vill/model/expression/ParenthesisExpression.java +++ b/src/main/java/de/vill/model/expression/ParenthesisExpression.java @@ -3,7 +3,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import java.util.Collections; import java.util.List; @@ -76,7 +76,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { return getContent().getAsSum(additionalConstraints); } diff --git a/src/main/java/de/vill/model/expression/StringExpression.java b/src/main/java/de/vill/model/expression/StringExpression.java index 391d53b..6ffbb27 100644 --- a/src/main/java/de/vill/model/expression/StringExpression.java +++ b/src/main/java/de/vill/model/expression/StringExpression.java @@ -3,7 +3,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.*; @@ -82,7 +82,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); } diff --git a/src/main/java/de/vill/model/expression/SubExpression.java b/src/main/java/de/vill/model/expression/SubExpression.java index d5382d8..4af3b94 100644 --- a/src/main/java/de/vill/model/expression/SubExpression.java +++ b/src/main/java/de/vill/model/expression/SubExpression.java @@ -3,7 +3,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.*; @@ -78,7 +78,7 @@ public List getReferences() { return result; } - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalConstraints) { var result = left.getAsSum(additionalConstraints); var rightResult = right.getAsSum(additionalConstraints); for (Literal l : rightResult){ diff --git a/src/main/java/de/vill/model/pbc/PBCConstraint.java b/src/main/java/de/vill/model/pbc/PBConstraint.java similarity index 71% rename from src/main/java/de/vill/model/pbc/PBCConstraint.java rename to src/main/java/de/vill/model/pbc/PBConstraint.java index 24306c2..c64d162 100644 --- a/src/main/java/de/vill/model/pbc/PBCConstraint.java +++ b/src/main/java/de/vill/model/pbc/PBConstraint.java @@ -2,9 +2,14 @@ import java.util.List; -public class PBCConstraint { +public class PBConstraint { public List literalList; public int k; + public PBConstraintType type; + + public PBConstraint() { + type = PBConstraintType.GEQ; + } @Override public String toString() { @@ -17,7 +22,8 @@ public String toString() { } res += " " + l.name; } - res += " >= " + k; + res += " " + type + " " + k; return res; } } + diff --git a/src/main/java/de/vill/model/pbc/PBConstraintType.java b/src/main/java/de/vill/model/pbc/PBConstraintType.java new file mode 100644 index 0000000..2cb3c76 --- /dev/null +++ b/src/main/java/de/vill/model/pbc/PBConstraintType.java @@ -0,0 +1,25 @@ +package de.vill.model.pbc; + +public enum PBConstraintType { + GEQ(">="), + GE(">"), + LEQ("<="), + LE("<"), + EQ("="), + NOTEQ("!="); + + private String value; + + PBConstraintType(String value) { + this.value = value; + } + + public String getValue() { + return value; + } + + @Override + public String toString() { + return this.value; + } +} diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 1bb2c5c..3b9dd48 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -1,11 +1,11 @@ package de.vill.util; import de.vill.config.Configuration; -import de.vill.model.Attribute; import de.vill.model.constraint.*; import de.vill.model.expression.*; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; +import de.vill.model.pbc.PBConstraintType; import java.io.IOException; import java.nio.file.Files; @@ -14,7 +14,6 @@ import java.util.LinkedList; import java.util.List; import java.util.Map; -import java.util.function.ToDoubleBiFunction; import java.util.stream.Collectors; public class Util { @@ -88,17 +87,17 @@ public static boolean isJustOr(Constraint constraint){ return false; } - public static List transformImplicationMap (HashMap> implicationMap, int counter){ - List resultList = new LinkedList<>(); + public static List transformImplicationMap (HashMap> implicationMap, int counter){ + List resultList = new LinkedList<>(); int max = 0; - for (Map.Entry> entry : implicationMap.entrySet()) { + for (Map.Entry> entry : implicationMap.entrySet()) { int x = entry.getKey(); if(x > max) { max = x; } - for(PBCConstraint constraint : entry.getValue()){ + for(PBConstraint constraint : entry.getValue()){ //x <=> constraint - PBCConstraint c2 = new PBCConstraint(); + PBConstraint c2 = new PBConstraint(); c2.literalList = new LinkedList<>(); c2.k = constraint.k; for(Literal lit : constraint.literalList){ @@ -137,27 +136,27 @@ public static List transformImplicationMap (HashMap(); + PBConstraint finalPBConstraint = new PBConstraint(); + finalPBConstraint.literalList = new LinkedList<>(); Literal l = new Literal(); l.factor = 1; l.name = "x_" + counter + "_" + max; - finalPBCConstraint.literalList.add(l); - finalPBCConstraint.k = 1; - resultList.add(finalPBCConstraint); + finalPBConstraint.literalList.add(l); + finalPBConstraint.k = 1; + resultList.add(finalPBConstraint); return resultList; } - public static HashMap> transformSubFormulas(HashMap subformulas, List additionalConstraints){ - HashMap> resultMap = new HashMap<>(); + public static HashMap> transformSubFormulas(HashMap subformulas, List additionalConstraints){ + HashMap> resultMap = new HashMap<>(); for (Map.Entry entry : subformulas.entrySet()) { resultMap.put(entry.getKey(), transformSubFormula(entry.getValue(), additionalConstraints)); } return resultMap; } - public static List transformSubFormula(Constraint constraint, List additionalConstraints){ - List resultList = new LinkedList<>(); + public static List transformSubFormula(Constraint constraint, List additionalConstraints){ + List resultList = new LinkedList<>(); if(constraint instanceof NotConstraint){ resultList.add(transformNegLiteral((NotConstraint) constraint)); } else if (constraint instanceof ImplicationConstraint) { @@ -180,18 +179,18 @@ else if (constraint instanceof ExpressionConstraint) { return resultList; } - public static PBCConstraint transformNegLiteral(NotConstraint constraint){ + public static PBConstraint transformNegLiteral(NotConstraint constraint){ Literal literal = new Literal(); literal.name = ((LiteralConstraint)constraint.getContent()).getReference().getIdentifier(); literal.factor = -1; - PBCConstraint pbcConstraint = new PBCConstraint(); - pbcConstraint.k = 0; - pbcConstraint.literalList = new LinkedList<>(); - pbcConstraint.literalList.add(literal); - return pbcConstraint; + PBConstraint PBConstraint = new PBConstraint(); + PBConstraint.k = 0; + PBConstraint.literalList = new LinkedList<>(); + PBConstraint.literalList.add(literal); + return PBConstraint; } - public static PBCConstraint transformImplication(ImplicationConstraint constraint){ + public static PBConstraint transformImplication(ImplicationConstraint constraint){ Constraint c1 = constraint.getLeft(); Constraint c2 = constraint.getRight(); Literal l1 = new Literal(); @@ -201,49 +200,49 @@ public static PBCConstraint transformImplication(ImplicationConstraint constrain l2.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); l1.factor = 1; l2.factor = -1; - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.k = 0; - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.literalList.add(l1); - pbcConstraint1.literalList.add(l2); - return pbcConstraint1; + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = 0; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); + return PBConstraint1; }else if(c1 instanceof LiteralConstraint && c2 instanceof LiteralConstraint){ l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); l2.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); l1.factor = -1; l2.factor = 1; - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.k = 0; - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.literalList.add(l1); - pbcConstraint1.literalList.add(l2); - return pbcConstraint1; + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = 0; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); + return PBConstraint1; }else if (c1 instanceof NotConstraint) { l1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); l1.factor = 1; l2.name = ((LiteralConstraint) (c2)).getReference().getIdentifier(); l2.factor = 1; - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.k = 1; - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.literalList.add(l1); - pbcConstraint1.literalList.add(l2); - return pbcConstraint1; + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = 1; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); + return PBConstraint1; }else{ l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); l2.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); l1.factor = -1; l2.factor = -1; - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.k = -1; - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.literalList.add(l1); - pbcConstraint1.literalList.add(l2); - return pbcConstraint1; + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = -1; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); + return PBConstraint1; } } - public static List transformBiImplication(EquivalenceConstraint constraint){ + public static List transformBiImplication(EquivalenceConstraint constraint){ Constraint c1 = constraint.getLeft(); Constraint c2 = constraint.getRight(); Literal l1 = new Literal(); @@ -253,11 +252,11 @@ public static List transformBiImplication(EquivalenceConstraint c l2.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); l1.factor = 1; l2.factor = -1; - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.k = 0; - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.literalList.add(l1); - pbcConstraint1.literalList.add(l2); + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = 0; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); Literal l1_1 = new Literal(); Literal l2_1 = new Literal(); @@ -265,26 +264,26 @@ public static List transformBiImplication(EquivalenceConstraint c l2_1.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); l1_1.factor = -1; l2_1.factor = 1; - PBCConstraint pbcConstraint2 = new PBCConstraint(); - pbcConstraint2.k = 0; - pbcConstraint2.literalList = new LinkedList<>(); - pbcConstraint2.literalList.add(l1_1); - pbcConstraint2.literalList.add(l2_1); - - List constraintList = new LinkedList<>(); - constraintList.add(pbcConstraint1); - constraintList.add(pbcConstraint2); + PBConstraint PBConstraint2 = new PBConstraint(); + PBConstraint2.k = 0; + PBConstraint2.literalList = new LinkedList<>(); + PBConstraint2.literalList.add(l1_1); + PBConstraint2.literalList.add(l2_1); + + List constraintList = new LinkedList<>(); + constraintList.add(PBConstraint1); + constraintList.add(PBConstraint2); return constraintList; }else if(c1 instanceof LiteralConstraint && c2 instanceof LiteralConstraint){ l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); l2.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); l1.factor = 1; l2.factor = -1; - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.k = 0; - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.literalList.add(l1); - pbcConstraint1.literalList.add(l2); + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = 0; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); Literal l1_1 = new Literal(); Literal l2_1 = new Literal(); @@ -292,26 +291,26 @@ public static List transformBiImplication(EquivalenceConstraint c l2_1.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); l1_1.factor = -1; l2_1.factor = 1; - PBCConstraint pbcConstraint2 = new PBCConstraint(); - pbcConstraint2.k = 0; - pbcConstraint2.literalList = new LinkedList<>(); - pbcConstraint2.literalList.add(l1_1); - pbcConstraint2.literalList.add(l2_1); - - List constraintList = new LinkedList<>(); - constraintList.add(pbcConstraint1); - constraintList.add(pbcConstraint2); + PBConstraint PBConstraint2 = new PBConstraint(); + PBConstraint2.k = 0; + PBConstraint2.literalList = new LinkedList<>(); + PBConstraint2.literalList.add(l1_1); + PBConstraint2.literalList.add(l2_1); + + List constraintList = new LinkedList<>(); + constraintList.add(PBConstraint1); + constraintList.add(PBConstraint2); return constraintList; }else if (c1 instanceof NotConstraint) { l1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); l1.factor = -1; l2.name = ((LiteralConstraint) (c2)).getReference().getIdentifier(); l2.factor = -1; - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.k = -1; - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.literalList.add(l1); - pbcConstraint1.literalList.add(l2); + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = -1; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); Literal l1_1 = new Literal(); l1_1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); @@ -319,25 +318,25 @@ public static List transformBiImplication(EquivalenceConstraint c Literal l2_1 = new Literal(); l2_1.name = ((LiteralConstraint) c2).getReference().getIdentifier(); l2_1.factor = 1; - PBCConstraint pbcConstraint2 = new PBCConstraint(); - pbcConstraint2.k = 1; - pbcConstraint2.literalList = new LinkedList<>(); - pbcConstraint2.literalList.add(l1_1); - pbcConstraint2.literalList.add(l2_1); - List constraintList = new LinkedList<>(); - constraintList.add(pbcConstraint1); - constraintList.add(pbcConstraint2); + PBConstraint PBConstraint2 = new PBConstraint(); + PBConstraint2.k = 1; + PBConstraint2.literalList = new LinkedList<>(); + PBConstraint2.literalList.add(l1_1); + PBConstraint2.literalList.add(l2_1); + List constraintList = new LinkedList<>(); + constraintList.add(PBConstraint1); + constraintList.add(PBConstraint2); return constraintList; }else{ l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); l2.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); l1.factor = 1; l2.factor = 1; - PBCConstraint pbcConstraint1 = new PBCConstraint(); - pbcConstraint1.k = 1; - pbcConstraint1.literalList = new LinkedList<>(); - pbcConstraint1.literalList.add(l1); - pbcConstraint1.literalList.add(l2); + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = 1; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); Literal l1_1 = new Literal(); Literal l2_1 = new Literal(); @@ -345,80 +344,103 @@ public static List transformBiImplication(EquivalenceConstraint c l2_1.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); l1_1.factor = -1; l2_1.factor = -1; - PBCConstraint pbcConstraint2 = new PBCConstraint(); - pbcConstraint2.k = -1; - pbcConstraint2.literalList = new LinkedList<>(); - pbcConstraint2.literalList.add(l1_1); - pbcConstraint2.literalList.add(l2_1); - - List constraintList = new LinkedList<>(); - constraintList.add(pbcConstraint1); - constraintList.add(pbcConstraint2); + PBConstraint PBConstraint2 = new PBConstraint(); + PBConstraint2.k = -1; + PBConstraint2.literalList = new LinkedList<>(); + PBConstraint2.literalList.add(l1_1); + PBConstraint2.literalList.add(l2_1); + + List constraintList = new LinkedList<>(); + constraintList.add(PBConstraint1); + constraintList.add(PBConstraint2); return constraintList; } } - public static PBCConstraint transformAnd(Constraint constraint){ + public static PBConstraint transformAnd(Constraint constraint){ if(constraint instanceof AndConstraint){ - PBCConstraint pbcConstraint1 = transformAnd(((AndConstraint) constraint).getLeft()); - PBCConstraint pbcConstraint2 = transformAnd(((AndConstraint) constraint).getRight()); - pbcConstraint1.k = pbcConstraint1.k + pbcConstraint2.k; - pbcConstraint1.literalList.addAll(pbcConstraint2.literalList); - return pbcConstraint1; + PBConstraint PBConstraint1 = transformAnd(((AndConstraint) constraint).getLeft()); + PBConstraint PBConstraint2 = transformAnd(((AndConstraint) constraint).getRight()); + PBConstraint1.k = PBConstraint1.k + PBConstraint2.k; + PBConstraint1.literalList.addAll(PBConstraint2.literalList); + return PBConstraint1; }else{ Literal l1 = new Literal(); - PBCConstraint pbcConstraint = new PBCConstraint(); + PBConstraint PBConstraint = new PBConstraint(); if(constraint instanceof NotConstraint){ l1.name = ((LiteralConstraint)((NotConstraint) constraint).getContent()).getReference().getIdentifier(); l1.factor = -1; - pbcConstraint.k = 0; + PBConstraint.k = 0; }else{ l1.name = ((LiteralConstraint)constraint).getReference().getIdentifier(); l1.factor = 1; - pbcConstraint.k = 1; + PBConstraint.k = 1; } - pbcConstraint.literalList = new LinkedList<>(); - pbcConstraint.literalList.add(l1); - return pbcConstraint; + PBConstraint.literalList = new LinkedList<>(); + PBConstraint.literalList.add(l1); + return PBConstraint; } } - public static PBCConstraint transformOr(Constraint constraint){ + public static PBConstraint transformOr(Constraint constraint){ if(constraint instanceof OrConstraint){ - PBCConstraint pbcConstraint1 = transformOr(((OrConstraint) constraint).getLeft()); - PBCConstraint pbcConstraint2 = transformOr(((OrConstraint) constraint).getRight()); - pbcConstraint1.k = pbcConstraint1.k + pbcConstraint2.k; - pbcConstraint1.literalList.addAll(pbcConstraint2.literalList); - return pbcConstraint1; + PBConstraint PBConstraint1 = transformOr(((OrConstraint) constraint).getLeft()); + PBConstraint PBConstraint2 = transformOr(((OrConstraint) constraint).getRight()); + PBConstraint1.k = PBConstraint1.k + PBConstraint2.k; + PBConstraint1.literalList.addAll(PBConstraint2.literalList); + return PBConstraint1; }else{ Literal l1 = new Literal(); - PBCConstraint pbcConstraint = new PBCConstraint(); + PBConstraint PBConstraint = new PBConstraint(); if(constraint instanceof NotConstraint){ l1.name = ((LiteralConstraint)((NotConstraint) constraint).getContent()).getReference().getIdentifier(); l1.factor = -1; - pbcConstraint.k = -1; + PBConstraint.k = -1; }else{ l1.name = ((LiteralConstraint)constraint).getReference().getIdentifier(); l1.factor = 1; - pbcConstraint.k = 0; + PBConstraint.k = 0; } - pbcConstraint.literalList = new LinkedList<>(); - pbcConstraint.literalList.add(l1); - return pbcConstraint; + PBConstraint.literalList = new LinkedList<>(); + PBConstraint.literalList.add(l1); + return PBConstraint; } } - public static PBCConstraint transformExpression(ExpressionConstraint constraint, List additionalConstraints) { - //TODO constraint.removeDiv + public static PBConstraint transformExpression(ExpressionConstraint constraint, List additionalConstraints) { + //transform all divisions to multiplications and ensure with additional constraints that denominators are not null + List denominatorListLeftSide = new LinkedList<>(); + List denominatorListRightSide = new LinkedList<>(); + List allDenominators = new LinkedList<>(); + reorderDenominators(constraint.getLeft(), denominatorListLeftSide, denominatorListRightSide, 0); + reorderDenominators(constraint.getRight(), denominatorListRightSide, denominatorListLeftSide, 0); + collectDenominators(constraint.getLeft(), allDenominators); + collectDenominators(constraint.getRight(), allDenominators); + additionalConstraints.addAll(getConstraintsToForbidZeroDivision(allDenominators)); + constraint.setLeft(removeAllDenominators(constraint.getLeft())); + constraint.setRight(removeAllDenominators(constraint.getRight())); + while (!denominatorListLeftSide.isEmpty()) { + constraint.setLeft(new MulExpression(constraint.getLeft(), denominatorListLeftSide.get(0))); + denominatorListLeftSide.remove(0); + } + while (!denominatorListRightSide.isEmpty()) { + constraint.setRight(new MulExpression(constraint.getRight(), denominatorListRightSide.get(0))); + denominatorListRightSide.remove(0); + } + + //transform everything to a sum var leftSum = constraint.getLeft().getAsSum(additionalConstraints); var rightSum = constraint.getRight().getAsSum(additionalConstraints); + //take all numbers to the right side rightSum.addAll(leftSum.stream().filter(x -> x.name == null).collect(Collectors.toList())); leftSum = leftSum.stream().filter(x -> x.name != null).collect(Collectors.toList()); + //take all variables with factors to the left side leftSum.addAll(rightSum.stream().filter(x -> x.name != null).collect(Collectors.toList())); rightSum = rightSum.stream().filter(x -> x.name == null).collect(Collectors.toList()); + //sum app factors with same variable HashMap literalMap = new HashMap<>(); for (Literal l : leftSum) { if (literalMap.containsKey(l.name)) { @@ -427,13 +449,88 @@ public static PBCConstraint transformExpression(ExpressionConstraint constraint, literalMap.put(l.name, l.factor); } } - PBCConstraint pbcConstraint = new PBCConstraint(); - pbcConstraint.k = rightSum.stream().map(x -> x.factor).reduce(0, Integer::sum); - pbcConstraint.literalList = new LinkedList<>(); + + //create constraint + PBConstraint pbConstraint = new PBConstraint(); + if ("==".equals(constraint.getExpressionSymbol())) { + pbConstraint.type = PBConstraintType.EQ; + } else if ("<".equals(constraint.getExpressionSymbol())) { + pbConstraint.type = PBConstraintType.LE; + } else if (">".equals(constraint.getExpressionSymbol())) { + pbConstraint.type = PBConstraintType.GE; + } else if (">=".equals(constraint.getExpressionSymbol())) { + pbConstraint.type = PBConstraintType.GEQ; + } else if ("<=".equals(constraint.getExpressionSymbol())) { + pbConstraint.type = PBConstraintType.LEQ; + } else if ("!=".equals(constraint.getExpressionSymbol())) { + pbConstraint.type = PBConstraintType.NOTEQ; + } + pbConstraint.k = rightSum.stream().map(x -> x.factor).reduce(0, Integer::sum); + pbConstraint.literalList = new LinkedList<>(); for (Map.Entry e : literalMap.entrySet()) { - pbcConstraint.literalList.add(new Literal(e.getValue(), e.getKey())); + pbConstraint.literalList.add(new Literal(e.getValue(), e.getKey())); + } + + return pbConstraint; + } + + public static void reorderDenominators(Expression expression, List denominatorListSameSide, List denominatorListOtherSide, int denominatorDepth) { + if (expression instanceof DivExpression) { + var divExpression = (DivExpression)expression; + reorderDenominators(divExpression.getLeft(), denominatorListSameSide, denominatorListOtherSide, denominatorDepth); + reorderDenominators(divExpression.getRight(), denominatorListSameSide, denominatorListOtherSide, denominatorDepth + 1); + }else if (expression instanceof LiteralExpression || expression instanceof NumberExpression) { + if (denominatorDepth > 0) { + if (denominatorDepth % 2 == 0) { + denominatorListSameSide.add(expression); + }else { + denominatorListOtherSide.add(expression); + } + } + }else{ + for (Expression subExpression : expression.getExpressionSubParts()){ + reorderDenominators(subExpression, denominatorListSameSide, denominatorListOtherSide, denominatorDepth); + } + } + } + + public static void collectDenominators(Expression expression, List denominators) { + if (expression instanceof DivExpression){ + denominators.add(((DivExpression) expression).getRight()); + } + for (Expression subExpression : expression.getExpressionSubParts()){ + collectDenominators(subExpression, denominators); + } + } + + public static Expression removeAllDenominators(Expression expression) { + if (expression instanceof DivExpression){ + return removeAllDenominators(((DivExpression) expression).getLeft()); + }else { + HashMap newSubParts = new HashMap<>(); + for (Expression subExpression : expression.getExpressionSubParts()){ + newSubParts.put(subExpression, removeAllDenominators(subExpression)); + } + for (Map.Entry entry : newSubParts.entrySet()){ + expression.replaceExpressionSubPart(entry.getKey(), entry.getValue()); + } + return expression; } + } - return pbcConstraint; + public static List getConstraintsToForbidZeroDivision(List denominators) { + List additionalConstraints = new LinkedList<>(); + for (Expression denominator : denominators){ + removeAllDenominators(denominator); + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.k = 0; + pbConstraint.type = PBConstraintType.NOTEQ; + pbConstraint.literalList = new LinkedList<>(); + for (Literal l : denominator.getAsSum(additionalConstraints)) { + pbConstraint.literalList.add(l); + } + additionalConstraints.add(pbConstraint); + } + return additionalConstraints; } } From 0822b6b42abdafe6a9607308e0895e55ed652e29 Mon Sep 17 00:00:00 2001 From: Stefan Date: Wed, 23 Oct 2024 16:41:19 +0200 Subject: [PATCH 14/60] feat: pseudo boolean encoding of feature attribute constraints that contain doubles by encoding them in integer values --- .../model/expression/LiteralExpression.java | 5 ++- .../model/expression/NumberExpression.java | 2 +- src/main/java/de/vill/model/pbc/Literal.java | 4 +-- .../java/de/vill/model/pbc/PBConstraint.java | 34 ++++++++++++++++--- src/main/java/de/vill/util/Util.java | 8 ++--- 5 files changed, 39 insertions(+), 14 deletions(-) diff --git a/src/main/java/de/vill/model/expression/LiteralExpression.java b/src/main/java/de/vill/model/expression/LiteralExpression.java index add364b..79e1553 100644 --- a/src/main/java/de/vill/model/expression/LiteralExpression.java +++ b/src/main/java/de/vill/model/expression/LiteralExpression.java @@ -127,10 +127,9 @@ public List getReferences() { @Override public List getAsSum(List additionalConstraints) { Literal l = new Literal(); - //TODO handle more than just Long attributes - var attribute = (Attribute)getContent(); + var attribute = (Attribute)getContent(); l.name = attribute.getFeature().getFeatureName(); - l.factor = Math.toIntExact((attribute.getValue())); + l.factor = attribute.getValue() instanceof Long ? ((Long) attribute.getValue()).doubleValue() : (double) attribute.getValue(); List result = new LinkedList<>(); result.add(l); return result; diff --git a/src/main/java/de/vill/model/expression/NumberExpression.java b/src/main/java/de/vill/model/expression/NumberExpression.java index 9424a2e..3c304ad 100644 --- a/src/main/java/de/vill/model/expression/NumberExpression.java +++ b/src/main/java/de/vill/model/expression/NumberExpression.java @@ -87,7 +87,7 @@ public List getReferences() { @Override public List getAsSum(List additionalConstraints) { List result = new LinkedList<>(); - result.add(new Literal((int) number, null)); + result.add(new Literal(number, null)); return result; } diff --git a/src/main/java/de/vill/model/pbc/Literal.java b/src/main/java/de/vill/model/pbc/Literal.java index d899589..f201412 100644 --- a/src/main/java/de/vill/model/pbc/Literal.java +++ b/src/main/java/de/vill/model/pbc/Literal.java @@ -2,9 +2,9 @@ public class Literal { public String name; - public int factor; + public double factor; public Literal(){} - public Literal(int factor, String name) { + public Literal(double factor, String name) { this.name = name; this.factor = factor; } diff --git a/src/main/java/de/vill/model/pbc/PBConstraint.java b/src/main/java/de/vill/model/pbc/PBConstraint.java index c64d162..c248cab 100644 --- a/src/main/java/de/vill/model/pbc/PBConstraint.java +++ b/src/main/java/de/vill/model/pbc/PBConstraint.java @@ -4,7 +4,7 @@ public class PBConstraint { public List literalList; - public int k; + public double k; public PBConstraintType type; public PBConstraint() { @@ -13,17 +13,43 @@ public PBConstraint() { @Override public String toString() { + int maxDecimalPlaces = getMaxDecimalPlaces(); String res = ""; for(Literal l : literalList){ if(l.factor < 0){ - res += " " + l.factor; + res += " " + (long) (l.factor * Math.pow(10,maxDecimalPlaces)); }else{ - res += " +" + l.factor; + res += " +" + (long) (l.factor * Math.pow(10,maxDecimalPlaces)); } res += " " + l.name; } - res += " " + type + " " + k; + res += " " + type + " " + (long) (k * Math.pow(10,maxDecimalPlaces)); return res; } + + private int getMaxDecimalPlaces() { + int maxDecimalPlaces = 0; + int kDecimalPlaces = countDecimalPlaces(k); + if (kDecimalPlaces > maxDecimalPlaces) { + maxDecimalPlaces = kDecimalPlaces; + } + for (Literal l : literalList) { + int lDecimalPlaces = countDecimalPlaces(l.factor); + if (lDecimalPlaces > maxDecimalPlaces) { + maxDecimalPlaces = lDecimalPlaces; + } + } + return maxDecimalPlaces; + } + + private int countDecimalPlaces(double value) { + String text = String.valueOf(value); + + if (text.contains(".")) { + return text.length() - text.indexOf('.') - 1; + } else { + return 0; + } + } } diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 3b9dd48..be2de83 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -108,7 +108,7 @@ public static List transformImplicationMap (HashMap x.name == null).collect(Collectors.toList()); //sum app factors with same variable - HashMap literalMap = new HashMap<>(); + HashMap literalMap = new HashMap<>(); for (Literal l : leftSum) { if (literalMap.containsKey(l.name)) { literalMap.put(l.name, literalMap.get(l.name) + l.factor); @@ -465,9 +465,9 @@ public static PBConstraint transformExpression(ExpressionConstraint constraint, } else if ("!=".equals(constraint.getExpressionSymbol())) { pbConstraint.type = PBConstraintType.NOTEQ; } - pbConstraint.k = rightSum.stream().map(x -> x.factor).reduce(0, Integer::sum); + pbConstraint.k = rightSum.stream().map(x -> x.factor).reduce(0.0, Double::sum); pbConstraint.literalList = new LinkedList<>(); - for (Map.Entry e : literalMap.entrySet()) { + for (Map.Entry e : literalMap.entrySet()) { pbConstraint.literalList.add(new Literal(e.getValue(), e.getKey())); } From e88e6dc72a6c00c2b030b8c000878c73bd745316 Mon Sep 17 00:00:00 2001 From: Stefan Date: Wed, 23 Oct 2024 16:43:35 +0200 Subject: [PATCH 15/60] refactor: renaming --- src/main/java/de/vill/main/Example.java | 26 +++++++++++-------------- 1 file changed, 11 insertions(+), 15 deletions(-) diff --git a/src/main/java/de/vill/main/Example.java b/src/main/java/de/vill/main/Example.java index e217870..de7779d 100644 --- a/src/main/java/de/vill/main/Example.java +++ b/src/main/java/de/vill/main/Example.java @@ -1,20 +1,16 @@ package de.vill.main; -import de.vill.config.Configuration; import de.vill.model.*; import de.vill.model.constraint.Constraint; import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCConstraint; +import de.vill.model.pbc.PBConstraint; -import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.*; -import static de.vill.util.Util.*; - public class Example { public static void main(String[] args) throws IOException { @@ -52,34 +48,34 @@ public static void main(String[] args) throws IOException { private static void dimacsToOPB(String path) throws IOException { String[] lines = new String(Files.readAllBytes(Paths.get(path))).split("\n"); - List constraintList = new LinkedList<>(); + List constraintList = new LinkedList<>(); for(String line : lines){ if(!line.startsWith("c") && !line.startsWith("p")){ - PBCConstraint pbcConstraint = new PBCConstraint(); - pbcConstraint.literalList = new LinkedList<>(); - pbcConstraint.k = 1; + PBConstraint PBConstraint = new PBConstraint(); + PBConstraint.literalList = new LinkedList<>(); + PBConstraint.k = 1; for(String l : line.split(" ")){ int v = Integer.parseInt(l); if(v > 0){ Literal literal = new Literal(); literal.name = "x_" + v; literal.factor = 1; - pbcConstraint.literalList.add(literal); + PBConstraint.literalList.add(literal); }else if(v < 0){ Literal literal = new Literal(); literal.name = "x_" + (-1 * v); literal.factor = -1; - pbcConstraint.literalList.add(literal); - pbcConstraint.k = pbcConstraint.k -1; + PBConstraint.literalList.add(literal); + PBConstraint.k = PBConstraint.k -1; } } - constraintList.add(pbcConstraint); + constraintList.add(PBConstraint); } } - for(PBCConstraint pbcConstraint : constraintList){ - System.out.println(pbcConstraint.toString() + ";"); + for(PBConstraint PBConstraint : constraintList){ + System.out.println(PBConstraint.toString() + ";"); } } From 3e8bb40a0f6a2256de161e1614ee491d9c35d071 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 24 Oct 2024 09:25:11 +0200 Subject: [PATCH 16/60] fix: check for division by 0 in smt conversion --- .../java/de/vill/model/constraint/ExpressionConstraint.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index 018a2fb..fb3d808 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -74,6 +74,9 @@ public void replaceConstraintSubPart(Constraint oldSubConstraint, Constraint new public boolean evaluate(Set selectedFeatures) { double leftResult = left.evaluate(selectedFeatures); double rightResult = right.evaluate(selectedFeatures); + if (Double.isNaN(leftResult) || Double.isNaN(rightResult)){ + return false; + } if ("==".equals(expressionSymbol)) { return leftResult == rightResult; From 3667150b4701bf07b4b1a94e19f6c70394fe21c2 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 24 Oct 2024 09:40:10 +0200 Subject: [PATCH 17/60] fix: check for division by 0 in smt conversion --- .../java/de/vill/model/constraint/ExpressionConstraint.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index fb3d808..04938d3 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -74,7 +74,7 @@ public void replaceConstraintSubPart(Constraint oldSubConstraint, Constraint new public boolean evaluate(Set selectedFeatures) { double leftResult = left.evaluate(selectedFeatures); double rightResult = right.evaluate(selectedFeatures); - if (Double.isNaN(leftResult) || Double.isNaN(rightResult)){ + if (Double.isNaN(leftResult) || Double.isNaN(rightResult) || Double.isInfinite(leftResult) || Double.isInfinite(rightResult)){ return false; } From 70f2e3eb25fd43f7627d9b12229ea7cf81219c34 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 24 Oct 2024 09:40:50 +0200 Subject: [PATCH 18/60] fix: simplify and fix multiplication of number and literal (before handled as literal times literal) --- .../vill/model/expression/MulExpression.java | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/src/main/java/de/vill/model/expression/MulExpression.java b/src/main/java/de/vill/model/expression/MulExpression.java index 7beef31..f72911f 100644 --- a/src/main/java/de/vill/model/expression/MulExpression.java +++ b/src/main/java/de/vill/model/expression/MulExpression.java @@ -104,11 +104,19 @@ public List getAsSum(List additionalConstraints) { SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); for (int i=0;i Date: Thu, 24 Oct 2024 10:15:21 +0200 Subject: [PATCH 19/60] fix: wrong factor sign after denominator removal --- src/main/java/de/vill/util/Util.java | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index be2de83..35f5c6e 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -434,10 +434,18 @@ public static PBConstraint transformExpression(ExpressionConstraint constraint, var leftSum = constraint.getLeft().getAsSum(additionalConstraints); var rightSum = constraint.getRight().getAsSum(additionalConstraints); //take all numbers to the right side - rightSum.addAll(leftSum.stream().filter(x -> x.name == null).collect(Collectors.toList())); + List numbersFromLeftToRight = leftSum.stream().filter(x -> x.name == null).collect(Collectors.toList()); + for (Literal l : numbersFromLeftToRight){ + l.factor *= -1; + } + rightSum.addAll(numbersFromLeftToRight); leftSum = leftSum.stream().filter(x -> x.name != null).collect(Collectors.toList()); //take all variables with factors to the left side - leftSum.addAll(rightSum.stream().filter(x -> x.name != null).collect(Collectors.toList())); + List numbersFromRightToLeft = rightSum.stream().filter(x -> x.name != null).collect(Collectors.toList()); + for (Literal l : numbersFromRightToLeft){ + l.factor *= -1; + } + leftSum.addAll(numbersFromRightToLeft); rightSum = rightSum.stream().filter(x -> x.name == null).collect(Collectors.toList()); //sum app factors with same variable From bbc46be897ad28188703cb862258779011631137 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 24 Oct 2024 15:10:15 +0200 Subject: [PATCH 20/60] fix: error during biimplicatino transformation --- src/main/java/de/vill/util/Util.java | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 35f5c6e..0a63ed6 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -108,7 +108,7 @@ public static List transformImplicationMap (HashMap transformImplicationMap (HashMap Date: Fri, 25 Oct 2024 11:03:04 +0200 Subject: [PATCH 21/60] fix: fixed pseudo boolean encoding of division (now directly like all other mathematical operators) --- .../vill/model/expression/DivExpression.java | 63 +++++++++- src/main/java/de/vill/util/Util.java | 112 +++++++----------- 2 files changed, 103 insertions(+), 72 deletions(-) diff --git a/src/main/java/de/vill/model/expression/DivExpression.java b/src/main/java/de/vill/model/expression/DivExpression.java index fcf6ecc..f2e71e0 100644 --- a/src/main/java/de/vill/model/expression/DivExpression.java +++ b/src/main/java/de/vill/model/expression/DivExpression.java @@ -1,13 +1,19 @@ package de.vill.model.expression; +import com.google.common.collect.Sets; import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.constraint.Constraint; +import de.vill.model.constraint.LiteralConstraint; import de.vill.model.pbc.Literal; import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; +import de.vill.util.SubstitutionVariableIndex; import java.util.*; +import static de.vill.util.Util.substitutionConstraint; + public class DivExpression extends BinaryExpression { private Expression left; private Expression right; @@ -88,6 +94,61 @@ public List getReferences() { @Override public List getAsSum(List additionalConstraints) { - throw new UnsupportedOperationException("All DivExpressions must be removed before method is called."); + List result = new LinkedList<>(); + List numeratorSum = getLeft().getAsSum(additionalConstraints); + List denominatorSum = getRight().getAsSum(additionalConstraints); + SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); + for (Literal l : numeratorSum) { + Set> literalCombinations = getLiteralCombinations(new HashSet(denominatorSum)); + for (Set combination : literalCombinations) { + Literal newSummand = new Literal(); + newSummand.factor = l.factor; + double denominatorFactorSum = 0.0; + for (Literal denominatorLiteral : combination) { + denominatorFactorSum += denominatorLiteral.factor; + } + newSummand.factor /= denominatorFactorSum; + newSummand.name = substitutionVariableIndex.getIndex(); + result.add(newSummand); + PBConstraint denominatorConstraint = featureCombinationToPBConstraint(combination, denominatorSum); + denominatorConstraint.literalList.add(new Literal(1, l.name)); + denominatorConstraint.k += 1; + additionalConstraints.addAll(substitutionConstraint(denominatorConstraint, newSummand.name)); + //TODO add x <=> l & combination (with positive and negative literals) + } + } + return result; + } + + private Set> getLiteralCombinations(Set literals) { + Set> literalCombinations = new HashSet<>(); + for (int i = 1; i <= literals.size(); i++) { + literalCombinations.addAll(Sets.combinations(literals, i)); + } + return literalCombinations; + } + + private PBConstraint featureCombinationToPBConstraint(Set takenLiterals, List allLiterals) { + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = allLiterals.size(); + for (Literal literal : allLiterals) { + if (takenLiterals.contains(literal)) { + //literal positive in result + Literal newLiteral = new Literal(); + newLiteral.name = literal.name; + newLiteral.factor = 1; + pbConstraint.literalList.add(newLiteral); + }else { + //literal negative in result + Literal negatedLiteral = new Literal(); + negatedLiteral.name = literal.name; + negatedLiteral.factor = -1; + pbConstraint.k -= 1; + pbConstraint.literalList.add(negatedLiteral); + } + + } + return pbConstraint; } } diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 0a63ed6..62a508e 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -96,41 +96,7 @@ public static List transformImplicationMap (HashMap constraint - PBConstraint c2 = new PBConstraint(); - c2.literalList = new LinkedList<>(); - c2.k = constraint.k; - for(Literal lit : constraint.literalList){ - Literal l2 = new Literal(); - l2.factor = lit.factor; - l2.name = lit.name; - c2.literalList.add(l2); - } - - //-x v constraint - double f = Math.abs(constraint.k); - for(Literal lit : constraint.literalList){ - f += Math.abs(lit.factor); - } - Literal l1 = new Literal(); - l1.name = "x_" + counter + "_" + x; - l1.factor = -f; - constraint.k = constraint.k - f; - constraint.literalList.add(l1); - resultList.add(constraint); - - //x v -constraint - f = Math.abs(c2.k); - for(Literal lit : c2.literalList){ - f += Math.abs(lit.factor); - } - f *= -1; - c2.type = PBConstraintType.LE; - Literal l2 = new Literal(); - l2.name = "x_" + counter + "_" + x; - l2.factor = f; - c2.literalList.add(l2); - resultList.add(c2); + resultList.addAll(substitutionConstraint(constraint, "x_" + counter + "_" + x)); } } @@ -145,6 +111,46 @@ public static List transformImplicationMap (HashMap substitutionConstraint(PBConstraint constraint, String substitutionName) { + List resultList = new LinkedList<>(); + //x <=> constraint + PBConstraint c2 = new PBConstraint(); + c2.literalList = new LinkedList<>(); + c2.k = constraint.k; + for(Literal lit : constraint.literalList){ + Literal l2 = new Literal(); + l2.factor = lit.factor; + l2.name = lit.name; + c2.literalList.add(l2); + } + + //-x v constraint + double f = Math.abs(constraint.k); + for(Literal lit : constraint.literalList){ + f += Math.abs(lit.factor); + } + Literal l1 = new Literal(); + l1.name = substitutionName; + l1.factor = -f; + constraint.k = constraint.k - f; + constraint.literalList.add(l1); + resultList.add(constraint); + + //x v -constraint + f = Math.abs(c2.k); + for(Literal lit : c2.literalList){ + f += Math.abs(lit.factor); + } + f *= -1; + c2.type = PBConstraintType.LE; + Literal l2 = new Literal(); + l2.name = substitutionName; + l2.factor = f; + c2.literalList.add(l2); + resultList.add(c2); + return resultList; + } + public static HashMap> transformSubFormulas(HashMap subformulas, List additionalConstraints){ HashMap> resultMap = new HashMap<>(); for (Map.Entry entry : subformulas.entrySet()) { @@ -408,26 +414,10 @@ public static PBConstraint transformOr(Constraint constraint){ } public static PBConstraint transformExpression(ExpressionConstraint constraint, List additionalConstraints) { - //transform all divisions to multiplications and ensure with additional constraints that denominators are not null - List denominatorListLeftSide = new LinkedList<>(); - List denominatorListRightSide = new LinkedList<>(); List allDenominators = new LinkedList<>(); - reorderDenominators(constraint.getLeft(), denominatorListLeftSide, denominatorListRightSide, 0); - reorderDenominators(constraint.getRight(), denominatorListRightSide, denominatorListLeftSide, 0); collectDenominators(constraint.getLeft(), allDenominators); collectDenominators(constraint.getRight(), allDenominators); additionalConstraints.addAll(getConstraintsToForbidZeroDivision(allDenominators)); - constraint.setLeft(removeAllDenominators(constraint.getLeft())); - constraint.setRight(removeAllDenominators(constraint.getRight())); - //TODO: wrong! we also need multiply with both sides - while (!denominatorListLeftSide.isEmpty()) { - constraint.setLeft(new MulExpression(constraint.getLeft(), denominatorListLeftSide.get(0))); - denominatorListLeftSide.remove(0); - } - while (!denominatorListRightSide.isEmpty()) { - constraint.setRight(new MulExpression(constraint.getRight(), denominatorListRightSide.get(0))); - denominatorListRightSide.remove(0); - } //transform everything to a sum var leftSum = constraint.getLeft().getAsSum(additionalConstraints); @@ -481,26 +471,6 @@ public static PBConstraint transformExpression(ExpressionConstraint constraint, return pbConstraint; } - public static void reorderDenominators(Expression expression, List denominatorListSameSide, List denominatorListOtherSide, int denominatorDepth) { - if (expression instanceof DivExpression) { - var divExpression = (DivExpression)expression; - reorderDenominators(divExpression.getLeft(), denominatorListSameSide, denominatorListOtherSide, denominatorDepth); - reorderDenominators(divExpression.getRight(), denominatorListSameSide, denominatorListOtherSide, denominatorDepth + 1); - }else if (expression instanceof LiteralExpression || expression instanceof NumberExpression) { - if (denominatorDepth > 0) { - if (denominatorDepth % 2 == 0) { - denominatorListSameSide.add(expression); - }else { - denominatorListOtherSide.add(expression); - } - } - }else{ - for (Expression subExpression : expression.getExpressionSubParts()){ - reorderDenominators(subExpression, denominatorListSameSide, denominatorListOtherSide, denominatorDepth); - } - } - } - public static void collectDenominators(Expression expression, List denominators) { if (expression instanceof DivExpression){ denominators.add(((DivExpression) expression).getRight()); From b241f8f6d6a2e3e6446b1e2b8b62e9ee1ce49699 Mon Sep 17 00:00:00 2001 From: Stefan Date: Wed, 30 Oct 2024 12:28:06 +0100 Subject: [PATCH 22/60] multiple changes --- pom.xml | 5 - src/main/java/de/vill/main/Eval.java | 39 ++++++-- src/main/java/de/vill/model/Feature.java | 92 +++++++++++++------ src/main/java/de/vill/model/FeatureModel.java | 27 ++++-- src/main/java/de/vill/model/Group.java | 6 +- .../vill/model/constraint/AndConstraint.java | 3 + .../de/vill/model/constraint/Constraint.java | 5 +- .../constraint/EquivalenceConstraint.java | 2 +- .../constraint/ExpressionConstraint.java | 5 - .../model/constraint/LiteralConstraint.java | 1 + .../model/constraint/MultiOrConstraint.java | 5 +- .../vill/model/constraint/NotConstraint.java | 5 +- .../constraint/ParenthesisConstraint.java | 5 +- .../java/de/vill/model/pbc/OPBResult.java | 7 ++ .../java/de/vill/model/pbc/PBConstraint.java | 21 +++-- .../vill/util/SubstitutionVariableIndex.java | 4 + 16 files changed, 152 insertions(+), 80 deletions(-) create mode 100644 src/main/java/de/vill/model/pbc/OPBResult.java diff --git a/pom.xml b/pom.xml index 02f9016..eb4aa0f 100644 --- a/pom.xml +++ b/pom.xml @@ -76,11 +76,6 @@ antlr4-runtime 4.13.1 - - io.github.universal-variability-language - uvl-parser - 0.3 - org.junit.jupiter junit-jupiter diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index 9cca526..e1304ce 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -1,26 +1,37 @@ package de.vill.main; + +import de.ovgu.featureide.fm.core.base.IFeatureModel; +import de.ovgu.featureide.fm.core.base.impl.*; +import de.ovgu.featureide.fm.core.init.FMCoreLibrary; +import de.ovgu.featureide.fm.core.init.LibraryManager; +import de.ovgu.featureide.fm.core.io.dimacs.DIMACSFormat; +import de.ovgu.featureide.fm.core.io.manager.FeatureModelManager; +import de.ovgu.featureide.fm.core.io.manager.FileHandler; +import de.ovgu.featureide.fm.core.io.uvl.UVLFeatureModelFormat; import de.vill.model.FeatureModel; import de.vill.model.LanguageLevel; -import de.vill.model.constraint.Constraint; import java.io.*; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.HashMap; import java.util.HashSet; import java.util.Set; -import static de.vill.util.Util.transformSubFormulas; - public class Eval { public static final String WORKING_DIR = "/home/stefan/stefan-vill-master/tmp_eval/"; public static void main(String[] args) throws IOException { + long start = System.currentTimeMillis(); uvlToOPB("test"); - uvlToDimacs("test"); + long finish = System.currentTimeMillis(); + System.out.println("opb_encoding: " + (finish - start)); + start = System.currentTimeMillis(); + uvlToDimacsFeatureIDE("test"); + finish = System.currentTimeMillis(); + System.out.println("dimacs_encoding: " + (finish - start)); } public static void uvlToOPB(String modelName) throws IOException { @@ -34,12 +45,20 @@ public static void uvlToOPB(String modelName) throws IOException { } } - public static void uvlToDimacs(String modelName) throws IOException { + public static void uvlToDimacsFeatureIDE(String modelName) throws IOException { + LibraryManager.registerLibrary(FMCoreLibrary.getInstance()); + FMFormatManager.getInstance().addExtension(new UVLFeatureModelFormat()); + IFeatureModel featureModel = FeatureModelManager.load(Paths.get(WORKING_DIR + modelName + ".uvl")); + FileHandler.save(Paths.get(WORKING_DIR + modelName + ".dimacs"), featureModel, new DIMACSFormat()); + } + + public static void uvlToDimacsZ3(String modelName) throws IOException { uvlToSMT2(modelName + ".uvl", modelName + ".smt2"); smt2ToDimacs(modelName + ".smt2", modelName + ".dimacs"); } public static void smt2ToDimacs(String smt2Path, String dimacsPath) throws IOException { + long start = System.currentTimeMillis(); ProcessBuilder processBuilder = new ProcessBuilder(); processBuilder.command("python3", WORKING_DIR + "smt2ToDimacs.py", WORKING_DIR + smt2Path, WORKING_DIR + dimacsPath); @@ -55,13 +74,19 @@ public static void smt2ToDimacs(String smt2Path, String dimacsPath) throws IOExc // Wait for the process to complete and get the exit value int exitCode = process.waitFor(); + if (exitCode != 0) { + throw new IOException("Z3 error"); + } System.out.println("Process exited with code: " + exitCode); } catch (IOException | InterruptedException e) { e.printStackTrace(); } + long finish = System.currentTimeMillis(); + System.out.println("z3_with_io: " + (finish - start)); } public static void uvlToSMT2(String uvlPath, String dimacsPath) throws IOException { + long start = System.currentTimeMillis(); UVLModelFactory uvlModelFactory = new UVLModelFactory(); FeatureModel featureModel = loadUVLFeatureModelFromFile(WORKING_DIR + uvlPath); Set levels = new HashSet<>(); @@ -75,6 +100,8 @@ public static void uvlToSMT2(String uvlPath, String dimacsPath) throws IOExcepti } catch (IOException e) { System.err.println("Error writing to file: " + e.getMessage()); } + long finish = System.currentTimeMillis(); + System.out.println("smt_encoding_with_io: " + (finish - start)); } private static FeatureModel loadUVLFeatureModelFromFile(String path) throws IOException { diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index e729f2b..39252c5 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -12,6 +12,7 @@ import de.vill.config.Configuration; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.OPBResult; import de.vill.util.Util; /** @@ -369,69 +370,102 @@ public String toString() { return toString(true, ""); } - public String toOPBString() { - String result = ""; + public void toOPBString(OPBResult result) { List childGroups = getChildren(); for (Group group : childGroups){ switch (group.GROUPTYPE) { case OPTIONAL: - result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + result.opbString.append(group.getFeatures().size()); + result.opbString.append(" * "); + result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result += " -1 * " + child.getFeatureName().replace(" ", "_"); + result.opbString.append(" -1 * "); + result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result += " >= 0;\n"; + result.opbString.append(" >= 0;\n"); + result.numberConstraints++; break; case MANDATORY: - result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + result.opbString.append(group.getFeatures().size()); + result.opbString.append(" * "); + result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result += " -1 * " + child.getFeatureName().replace(" ", "_"); + result.opbString.append(" -1 * "); + result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result += " = 0;\n"; + result.opbString.append(" = 0;\n"); + result.numberConstraints += 2; break; case OR: - result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + result.opbString.append(group.getFeatures().size()); + result.opbString.append(" * "); + result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result += " -1 * " + child.getFeatureName().replace(" ", "_"); + result.opbString.append(" -1 * "); + result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result += " <= " + (group.getFeatures().size() - 1) + ";\n"; - result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + result.opbString.append(" <= "); + result.opbString.append(group.getFeatures().size() - 1); + result.opbString.append(";\n"); + result.numberConstraints++; + result.opbString.append(group.getFeatures().size()); + result.opbString.append(" * "); + result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result += " -1 * " + child.getFeatureName().replace(" ", "_"); + result.opbString.append(" -1 * "); + result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result += " >= 0;\n"; + result.opbString.append(" >= 0;\n"); + result.numberConstraints++; break; case ALTERNATIVE: - result += getFeatureName(); + result.opbString.append(getFeatureName()); for (Feature child : group.getFeatures()){ - result += " -1 * " + child.getFeatureName().replace(" ", "_"); + result.opbString.append(" -1 * "); + result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result += " = 0;\n"; + result.opbString.append(" = 0;\n"); + result.numberConstraints += 2; break; case GROUP_CARDINALITY: - result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + result.opbString.append(group.getFeatures().size()); + result.opbString.append(" * "); + result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result += " -1 * " + child.getFeatureName().replace(" ", "_"); + result.opbString.append(" -1 * "); + result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result += " >= 0;\n"; - result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + result.opbString.append(" >= 0;\n"); + result.numberConstraints++; + result.opbString.append(group.getFeatures().size()); + result.opbString.append(" * "); + result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result += " -1 * " + child.getFeatureName().replace(" ", "_"); + result.opbString.append(" -1 * "); + result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result += " >= " + (group.getFeatures().size() - group.getCardinality().upper) + ";\n"; - result += group.getFeatures().size() + " * " + getFeatureName().replace(" ", "_"); + result.opbString.append(" >= "); + result.opbString.append(group.getFeatures().size() - group.getCardinality().upper); + result.opbString.append(";\n"); + result.numberConstraints++; + result.opbString.append(group.getFeatures().size()); + result.opbString.append(" * "); + result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result += " -1 * " + child.getFeatureName().replace(" ", "_"); + result.opbString.append(" -1 * "); + result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result += " <= " + (group.getFeatures().size() - group.getCardinality().lower) + ";\n"; + result.opbString.append(" <= "); + result.opbString.append(group.getFeatures().size() - group.getCardinality().lower); + result.opbString.append(";\n"); } for (Feature child : group.getFeatures()){ + result.numberVariables++; if(child.getChildren().size() > 0) { - result += child.toOPBString(); + child.toOPBString(result); } } } - - return result; } /** diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 2280e12..d032b6b 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -15,7 +15,9 @@ import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; import de.vill.model.expression.LiteralExpression; +import de.vill.model.pbc.OPBResult; import de.vill.model.pbc.PBConstraint; +import de.vill.util.SubstitutionVariableIndex; import de.vill.util.Util; import static de.vill.util.Util.*; @@ -256,9 +258,12 @@ public String toString() { } public String toOPBString(){ - String result = ""; - result += getRootFeature().getFeatureName().replace(" ", "_") + " >= 1;\n"; - result += getRootFeature().toOPBString(); + OPBResult result = new OPBResult(); + result.numberVariables++; + result.opbString.append(getRootFeature().getFeatureName().replace(" ", "_")); + result.opbString.append(" >= 1;\n"); + result.numberConstraints++; + getRootFeature().toOPBString(result); int counter = 0; List constraints = getConstraints(); @@ -272,16 +277,22 @@ public String toOPBString(){ constraint.extractTseitinSubConstraints(subMap, n, counter); var map = transformSubFormulas(subMap, additionalConstraints); List pbcList = transformImplicationMap(map, counter); - for(PBConstraint PBConstraint : pbcList){ - result += PBConstraint.toString() + ";\n"; + for(PBConstraint pBConstraint : pbcList){ + result.numberVariables++; + pBConstraint.toOPBString(result); } counter++; } - for (PBConstraint PBConstraint : additionalConstraints){ - result += PBConstraint.toString() + ";\n"; + for (PBConstraint pBConstraint : additionalConstraints){ + pBConstraint.toOPBString(result); } - return result; + SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); + result.numberVariables += substitutionVariableIndex.peekIndex(); + String header = "#variable= " + result.numberVariables + " #constraint= " + result.numberConstraints + "\n"; + result.opbString.insert(0,header); + + return result.opbString.toString(); } public StringBuilder toSMT2string() { diff --git a/src/main/java/de/vill/model/Group.java b/src/main/java/de/vill/model/Group.java index cb00c1f..b633735 100644 --- a/src/main/java/de/vill/model/Group.java +++ b/src/main/java/de/vill/model/Group.java @@ -1,10 +1,6 @@ package de.vill.model; -import java.util.Collection; -import java.util.LinkedList; -import java.util.List; -import java.util.ListIterator; -import java.util.Objects; +import java.util.*; import de.vill.config.Configuration; import de.vill.model.constraint.Constraint; diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index 0aec80c..313e4d7 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -124,6 +124,9 @@ public StringBuilder toSMT2string() { builder.append("(and\n"); builder.append(left.toSMT2string()); builder.append("\n"); + if (right.toSMT2string().length() == 0) { + System.out.println("test"); + } builder.append(right.toSMT2string()); builder.append(")"); return builder; diff --git a/src/main/java/de/vill/model/constraint/Constraint.java b/src/main/java/de/vill/model/constraint/Constraint.java index 0a99aa9..915e93b 100644 --- a/src/main/java/de/vill/model/constraint/Constraint.java +++ b/src/main/java/de/vill/model/constraint/Constraint.java @@ -3,6 +3,7 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; +import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; @@ -48,7 +49,9 @@ public int extractTseitinSubConstraints(Map substitutionMap return 0; }; - public abstract StringBuilder toSMT2string(); + public StringBuilder toSMT2string(){ + return null; + } public List collectExpressions(){ List expressions = new LinkedList<>(); diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index 8322a36..888fb5b 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -117,7 +117,7 @@ public String getIdentifier() { @Override public StringBuilder toSMT2string() { StringBuilder builder = new StringBuilder(); - builder.append("(<=>\n"); + builder.append("(=\n"); builder.append(left.toSMT2string()); builder.append("\n"); builder.append(right.toSMT2string()); diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index 04938d3..847d25d 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -124,11 +124,6 @@ public List getReferences() { return references; } - @Override - public StringBuilder toSMT2string() { - return null; - } - @Override public List collectExpressions(){ List expressions = new LinkedList<>(); diff --git a/src/main/java/de/vill/model/constraint/LiteralConstraint.java b/src/main/java/de/vill/model/constraint/LiteralConstraint.java index 138e206..c5309c1 100644 --- a/src/main/java/de/vill/model/constraint/LiteralConstraint.java +++ b/src/main/java/de/vill/model/constraint/LiteralConstraint.java @@ -3,6 +3,7 @@ import de.vill.model.building.VariableReference; import de.vill.util.Util; +import java.util.HashMap; import java.util.List; import java.util.Objects; diff --git a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java index b7e3f61..b502b1a 100644 --- a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java +++ b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java @@ -2,10 +2,7 @@ import de.vill.model.building.VariableReference; -import java.util.ArrayList; -import java.util.LinkedList; -import java.util.List; -import java.util.Objects; +import java.util.*; public class MultiOrConstraint extends Constraint{ diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index c9e1427..84c91ed 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -2,10 +2,7 @@ import de.vill.model.building.VariableReference; -import java.util.Arrays; -import java.util.List; -import java.util.Map; -import java.util.Objects; +import java.util.*; public class NotConstraint extends Constraint { private Constraint content; diff --git a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java index 73c55c7..1a5bed4 100644 --- a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java +++ b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java @@ -2,10 +2,7 @@ import de.vill.model.building.VariableReference; -import java.util.Arrays; -import java.util.List; -import java.util.Map; -import java.util.Objects; +import java.util.*; public class ParenthesisConstraint extends Constraint { private Constraint content; diff --git a/src/main/java/de/vill/model/pbc/OPBResult.java b/src/main/java/de/vill/model/pbc/OPBResult.java new file mode 100644 index 0000000..b2ac179 --- /dev/null +++ b/src/main/java/de/vill/model/pbc/OPBResult.java @@ -0,0 +1,7 @@ +package de.vill.model.pbc; + +public class OPBResult { + public long numberVariables = 0; + public long numberConstraints = 0; + public StringBuilder opbString = new StringBuilder(); +} diff --git a/src/main/java/de/vill/model/pbc/PBConstraint.java b/src/main/java/de/vill/model/pbc/PBConstraint.java index c248cab..39f9922 100644 --- a/src/main/java/de/vill/model/pbc/PBConstraint.java +++ b/src/main/java/de/vill/model/pbc/PBConstraint.java @@ -11,20 +11,25 @@ public PBConstraint() { type = PBConstraintType.GEQ; } - @Override - public String toString() { + public void toOPBString(OPBResult result) { + result.numberConstraints++; int maxDecimalPlaces = getMaxDecimalPlaces(); - String res = ""; for(Literal l : literalList){ if(l.factor < 0){ - res += " " + (long) (l.factor * Math.pow(10,maxDecimalPlaces)); + result.opbString.append(" "); + result.opbString.append((long) (l.factor * Math.pow(10,maxDecimalPlaces))); }else{ - res += " +" + (long) (l.factor * Math.pow(10,maxDecimalPlaces)); + result.opbString.append(" +"); + result.opbString.append((long) (l.factor * Math.pow(10,maxDecimalPlaces))); } - res += " " + l.name; + result.opbString.append(" "); + result.opbString.append(l.name); } - res += " " + type + " " + (long) (k * Math.pow(10,maxDecimalPlaces)); - return res; + result.opbString.append(" "); + result.opbString.append(type); + result.opbString.append(" "); + result.opbString.append((long) (k * Math.pow(10,maxDecimalPlaces))); + result.opbString.append(";\n"); } private int getMaxDecimalPlaces() { diff --git a/src/main/java/de/vill/util/SubstitutionVariableIndex.java b/src/main/java/de/vill/util/SubstitutionVariableIndex.java index d7c67d7..d375a91 100644 --- a/src/main/java/de/vill/util/SubstitutionVariableIndex.java +++ b/src/main/java/de/vill/util/SubstitutionVariableIndex.java @@ -18,4 +18,8 @@ public String getIndex() { index++; return "sub_z_" + index; } + + public int peekIndex(){ + return index; + } } From 113fd4789ec7b25dead24634e38277104f2ec3ca Mon Sep 17 00:00:00 2001 From: Stefan Date: Wed, 30 Oct 2024 14:59:25 +0100 Subject: [PATCH 23/60] feat: automated evaluation --- src/main/java/de/vill/main/Eval.java | 130 ++++++++++++++++-- src/main/java/de/vill/model/Feature.java | 1 + src/main/java/de/vill/model/FeatureModel.java | 4 +- .../java/de/vill/util/CountingResult.java | 11 ++ .../java/de/vill/util/ModelEvalResult.java | 27 ++++ 5 files changed, 156 insertions(+), 17 deletions(-) create mode 100644 src/main/java/de/vill/util/CountingResult.java create mode 100644 src/main/java/de/vill/util/ModelEvalResult.java diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index e1304ce..8d021df 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -11,33 +11,133 @@ import de.ovgu.featureide.fm.core.io.uvl.UVLFeatureModelFormat; import de.vill.model.FeatureModel; import de.vill.model.LanguageLevel; +import de.vill.util.CountingResult; +import de.vill.util.ModelEvalResult; import java.io.*; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; import java.util.Set; public class Eval { public static final String WORKING_DIR = "/home/stefan/stefan-vill-master/tmp_eval/"; + public static final String D4_PATH = "/home/stefan/Downloads/d4/d4"; + public static final String P2D_PATH = "/home/stefan/p2d/target/release/p2d"; - public static void main(String[] args) throws IOException { - long start = System.currentTimeMillis(); - uvlToOPB("test"); - long finish = System.currentTimeMillis(); - System.out.println("opb_encoding: " + (finish - start)); - start = System.currentTimeMillis(); - uvlToDimacsFeatureIDE("test"); - finish = System.currentTimeMillis(); - System.out.println("dimacs_encoding: " + (finish - start)); + public static void main(String[] args) throws IOException, InterruptedException { + runEval(); + + } + + public static void runEval() throws IOException, InterruptedException { + List resultList = new LinkedList<>(); + File folder = Paths.get(WORKING_DIR, "models").toFile(); + File[] files = folder.listFiles(); + for (File f : files) { + resultList.add(evaluateModel(f)); + } + StringBuilder result = new StringBuilder(); + result.append("name;d4 time;p2d time;dimacs encoding time; opb encoding time; same result;solving-factor;encoding-factor;total-factor\n"); + for (ModelEvalResult r : resultList) { + result.append(r.toCSVString()); + result.append("\n"); + } + try (BufferedWriter writer = new BufferedWriter(new FileWriter(Paths.get(WORKING_DIR, "result.csv").toString()))) { + writer.append(result); + writer.flush(); + } catch (IOException e) { + System.err.println("Error writing to file: " + e.getMessage()); + } + } + + public static ModelEvalResult evaluateModel(File file) throws IOException, InterruptedException { + long totalTimeDimacs = 0; + final long NUMBER_RUNS = 1; + for (int i=0;i Date: Thu, 31 Oct 2024 17:48:38 +0100 Subject: [PATCH 24/60] fix: wrong opb encoding for group cardinality --- src/main/java/de/vill/model/Feature.java | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index 2a6199a..edee636 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -438,26 +438,29 @@ public void toOPBString(OPBResult result) { } result.opbString.append(" >= 0;\n"); result.numberConstraints++; - result.opbString.append(group.getFeatures().size()); + + + result.opbString.append("-"); + result.opbString.append(group.getCardinality().lower); result.opbString.append(" * "); result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result.opbString.append(" -1 * "); + result.opbString.append(" +1 * "); result.opbString.append(child.getFeatureName().replace(" ", "_")); } result.opbString.append(" >= "); - result.opbString.append(group.getFeatures().size() - group.getCardinality().upper); + result.opbString.append(0); result.opbString.append(";\n"); + + result.numberConstraints++; - result.opbString.append(group.getFeatures().size()); - result.opbString.append(" * "); result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result.opbString.append(" -1 * "); + result.opbString.append(" +1 * "); result.opbString.append(child.getFeatureName().replace(" ", "_")); } result.opbString.append(" <= "); - result.opbString.append(group.getFeatures().size() - group.getCardinality().lower); + result.opbString.append(group.getCardinality().upper + 1); result.opbString.append(";\n"); } for (Feature child : group.getFeatures()){ From 8fd6e48da42da46fc933226acd29a43c59368050 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 31 Oct 2024 17:49:30 +0100 Subject: [PATCH 25/60] fix: opb encoding for double negated literals --- src/main/java/de/vill/model/constraint/NotConstraint.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index 84c91ed..493cca9 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -69,9 +69,12 @@ public List getReferences() { } public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { + /* if (content instanceof LiteralConstraint){ return 0; } + + */ int a1 = content.extractTseitinSubConstraints(substitutionMapping, n, counter); int finalA = a1; Constraint l1 = new LiteralConstraint(new VariableReference() { From aa0860322df7aff2846a80a2ad6eb3628252c49b Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 31 Oct 2024 17:49:54 +0100 Subject: [PATCH 26/60] feat: eval pipeline --- src/main/java/de/vill/main/Eval.java | 52 +++++++++++++++---- .../java/de/vill/util/CountingResult.java | 4 +- .../java/de/vill/util/ModelEvalResult.java | 12 ++--- 3 files changed, 50 insertions(+), 18 deletions(-) diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index 8d021df..25e1e96 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -30,16 +30,36 @@ public class Eval { public static final String P2D_PATH = "/home/stefan/p2d/target/release/p2d"; public static void main(String[] args) throws IOException, InterruptedException { - runEval(); + runSingleFile("test.uvl"); + //runEval(); } + public static void runSingleFile(String modelName) throws IOException, InterruptedException { + File file = Paths.get(WORKING_DIR, modelName).toFile(); + ModelEvalResult result = evaluateModel(file); + System.out.println("name;d4 time;p2d time;dimacs encoding time; opb encoding time; same result;solving-factor;encoding-factor;total-factor"); + System.out.println(result.toCSVString()); + } public static void runEval() throws IOException, InterruptedException { + final int NUMBER_RUNS = 10; List resultList = new LinkedList<>(); File folder = Paths.get(WORKING_DIR, "models").toFile(); File[] files = folder.listFiles(); for (File f : files) { - resultList.add(evaluateModel(f)); + List tmpResultList = new LinkedList<>(); + for (int i=0;i x.TIME_TO_COMPUTE_D4).sum() / NUMBER_RUNS, + tmpResultList.stream().mapToDouble(x -> x.TIME_TO_COMPUTE_P2D).sum() / NUMBER_RUNS, + tmpResultList.get(0).MODEL_COUNT_D4, + tmpResultList.get(0).MODEL_COUNT_P2D, + tmpResultList.get(0).SAME_RESULT, + tmpResultList.stream().mapToDouble(x -> x.TO_DIMACS_TIME).sum() / NUMBER_RUNS, + tmpResultList.stream().mapToDouble(x -> x.TO_OPB_TIME).sum() / NUMBER_RUNS + )); } StringBuilder result = new StringBuilder(); result.append("name;d4 time;p2d time;dimacs encoding time; opb encoding time; same result;solving-factor;encoding-factor;total-factor\n"); @@ -56,7 +76,7 @@ public static void runEval() throws IOException, InterruptedException { } public static ModelEvalResult evaluateModel(File file) throws IOException, InterruptedException { - long totalTimeDimacs = 0; + double totalTimeDimacs = 0; final long NUMBER_RUNS = 1; for (int i=0;i levels = new HashSet<>(); + levels.add(LanguageLevel.BOOLEAN_LEVEL); + levels.add( LanguageLevel.TYPE_LEVEL); + uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); + try (BufferedWriter writer = new BufferedWriter(new FileWriter(Paths.get(WORKING_DIR, "tmp_files", file.getName() + "_sat_level.uvl").toString()))) { + writer.append(featureModel.toString()); + writer.flush(); + } catch (IOException e) { + System.err.println("Error writing to file: " + e.getMessage()); + } LibraryManager.registerLibrary(FMCoreLibrary.getInstance()); FMFormatManager.getInstance().addExtension(new UVLFeatureModelFormat()); - IFeatureModel featureModel = FeatureModelManager.load(Paths.get(WORKING_DIR, "models", file.getName())); - FileHandler.save(Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".dimacs"), featureModel, new DIMACSFormat()); + IFeatureModel fm = FeatureModelManager.load(Paths.get(WORKING_DIR, "tmp_files", file.getName() + "_sat_level.uvl")); + FileHandler.save(Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".dimacs"), fm, new DIMACSFormat()); } public static void uvlToDimacsZ3(String modelName) throws IOException { diff --git a/src/main/java/de/vill/util/CountingResult.java b/src/main/java/de/vill/util/CountingResult.java index a3b22a3..d314a32 100644 --- a/src/main/java/de/vill/util/CountingResult.java +++ b/src/main/java/de/vill/util/CountingResult.java @@ -1,10 +1,10 @@ package de.vill.util; public class CountingResult { - public final String TIME_TO_COMPUTE; + public final Double TIME_TO_COMPUTE; public final String MODEL_COUNT; - public CountingResult(String time, String result) { + public CountingResult(Double time, String result) { this.TIME_TO_COMPUTE = time; this.MODEL_COUNT = result; } diff --git a/src/main/java/de/vill/util/ModelEvalResult.java b/src/main/java/de/vill/util/ModelEvalResult.java index 704d997..40a4500 100644 --- a/src/main/java/de/vill/util/ModelEvalResult.java +++ b/src/main/java/de/vill/util/ModelEvalResult.java @@ -2,15 +2,15 @@ public class ModelEvalResult { public final String MODEL_NAME; - public final String TIME_TO_COMPUTE_D4; - public final String TIME_TO_COMPUTE_P2D; + public final Double TIME_TO_COMPUTE_D4; + public final Double TIME_TO_COMPUTE_P2D; public final String MODEL_COUNT_D4; public final String MODEL_COUNT_P2D; public final boolean SAME_RESULT; - public final long TO_DIMACS_TIME; - public final long TO_OPB_TIME; + public final Double TO_DIMACS_TIME; + public final Double TO_OPB_TIME; - public ModelEvalResult(String modelName, String timeToComputeD4, String timeToComputeP2D, String modelCountD4, String modelCountP2D, boolean sameResult, long toDimacsTime, long toOpbTime) { + public ModelEvalResult(String modelName, Double timeToComputeD4, Double timeToComputeP2D, String modelCountD4, String modelCountP2D, boolean sameResult, Double toDimacsTime, Double toOpbTime) { MODEL_NAME = modelName; TIME_TO_COMPUTE_D4 = timeToComputeD4; TIME_TO_COMPUTE_P2D = timeToComputeP2D; @@ -22,6 +22,6 @@ public ModelEvalResult(String modelName, String timeToComputeD4, String timeToCo } public String toCSVString() { - return MODEL_NAME + ";" + TIME_TO_COMPUTE_D4 + ";" + TIME_TO_COMPUTE_P2D + ";" + TO_DIMACS_TIME + ";" + TO_OPB_TIME + ";" + SAME_RESULT + ";" + Double.valueOf(TIME_TO_COMPUTE_P2D) / Double.valueOf(TIME_TO_COMPUTE_D4) + ";" + Double.valueOf(TO_OPB_TIME) / Double.valueOf(TO_DIMACS_TIME) + ";" + (Double.valueOf(TIME_TO_COMPUTE_P2D) + Double.valueOf(TO_OPB_TIME)) / (Double.valueOf(TIME_TO_COMPUTE_D4) + Double.valueOf(TO_DIMACS_TIME)); + return MODEL_NAME + ";" + TIME_TO_COMPUTE_D4 + ";" + TIME_TO_COMPUTE_P2D + ";" + TO_DIMACS_TIME + ";" + TO_OPB_TIME + ";" + SAME_RESULT + ";" + TIME_TO_COMPUTE_P2D / TIME_TO_COMPUTE_D4 + ";" + TO_OPB_TIME / TO_DIMACS_TIME + ";" + (TIME_TO_COMPUTE_P2D + TO_OPB_TIME) / (TIME_TO_COMPUTE_D4 + TO_DIMACS_TIME); } } From 4b8961473ed5877efe997819674201069e79d4a8 Mon Sep 17 00:00:00 2001 From: Stefan Date: Mon, 4 Nov 2024 08:34:31 +0100 Subject: [PATCH 27/60] fix: error in feature cardinality conversion strategy --- src/main/java/de/vill/model/Feature.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index edee636..f7c8ed7 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -624,7 +624,9 @@ private String attributesToString(boolean withSubmodels, String currentAlias) { public Feature clone() { Feature feature = new Feature(getFeatureName()); feature.setNameSpace(getNameSpace()); - feature.setCardinality(cardinality.clone()); + if (cardinality != null){ + feature.setCardinality(cardinality.clone()); + } feature.setSubmodelRoot(isSubmodelRoot); feature.setRelatedImport(getRelatedImport()); feature.setFeatureType(this.getFeatureType()); From 41ddad7eb6e1503e7152e384ebfb26dbc1d15401 Mon Sep 17 00:00:00 2001 From: Stefan Date: Mon, 4 Nov 2024 09:49:19 +0100 Subject: [PATCH 28/60] feat: encode feature cardinality in pseudo-boolean --- src/main/java/de/vill/main/Eval.java | 3 + .../util/ConvertFeatureCardinalityForOPB.java | 152 ++++++++++++++++++ 2 files changed, 155 insertions(+) create mode 100644 src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index 25e1e96..44733a3 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -11,6 +11,7 @@ import de.ovgu.featureide.fm.core.io.uvl.UVLFeatureModelFormat; import de.vill.model.FeatureModel; import de.vill.model.LanguageLevel; +import de.vill.util.ConvertFeatureCardinalityForOPB; import de.vill.util.CountingResult; import de.vill.util.ModelEvalResult; @@ -157,6 +158,8 @@ public static CountingResult runp2d(File file) throws IOException, InterruptedEx public static void uvlToOPB(File file) throws IOException { UVLModelFactory uvlModelFactory = new UVLModelFactory(); FeatureModel featureModel = loadUVLFeatureModelFromFile(file.toString()); + ConvertFeatureCardinalityForOPB convertFeatureCardinalityForOPB = new ConvertFeatureCardinalityForOPB(); + convertFeatureCardinalityForOPB.convertFeatureModel(featureModel); try (BufferedWriter writer = new BufferedWriter(new FileWriter(Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".opb").toString()))) { writer.append(featureModel.toOPBString()); writer.flush(); diff --git a/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java b/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java new file mode 100644 index 0000000..5cf3655 --- /dev/null +++ b/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java @@ -0,0 +1,152 @@ +package de.vill.util; + +import de.vill.conversion.IConversionStrategy; +import de.vill.model.*; +import de.vill.model.constraint.*; + +import javax.smartcardio.Card; +import java.util.*; + +public class ConvertFeatureCardinalityForOPB { + + public void convertFeatureModel(FeatureModel featureModel) { + traverseFeatures(featureModel.getRootFeature(), featureModel); + } + + private void traverseFeatures(Feature feature, FeatureModel featureModel) { + if (!feature.isSubmodelRoot()) { + if (feature.getCardinality() != null) { + List subTreeFeatures = new LinkedList<>(); + for (Group group : feature.getChildren()) { + subTreeFeatures.addAll(getFeatureFromSubTree(group)); + } + List constraintsToClone = getConstraintsOnSubTree(featureModel, subTreeFeatures); + + removeFeatureCardinality(feature, featureModel, constraintsToClone); + } + for (Group children : feature.getChildren()) { + for (Feature subFeature : children.getFeatures()) { + traverseFeatures(subFeature, featureModel); + } + } + } + } + + private void removeFeatureCardinality(Feature feature, FeatureModel featureModel, List constraintsToClone) { + int min = feature.getCardinality().lower; + int max = feature.getCardinality().upper; + Group newChildren = new Group(Group.GroupType.GROUP_CARDINALITY); + newChildren.setCardinality(new Cardinality(min, max)); + + feature.setCardinality(null); + + for (int i = min; i <= max; i++) { + Feature subTreeClone = feature.clone(); + addPrefixToNamesRecursively(subTreeClone, "_" + i); + newChildren.getFeatures().add(subTreeClone); + subTreeClone.setParentGroup(newChildren); + + Map constraintReplacementMap = new HashMap<>(); + createFeatureReplacementMap(feature, subTreeClone, constraintReplacementMap); + constraintReplacementMap.remove(feature.getFeatureName()); + for (Constraint constraint : constraintsToClone) { + Constraint newConstraint = constraint.clone(); + featureModel.getOwnConstraints().add(newConstraint); + adaptConstraint(subTreeClone, newConstraint, constraintReplacementMap); + } + } + for (int i = min; i < max; i++) { + Constraint lastTakenInGroupCardinality = new LiteralConstraint(newChildren.getFeatures().get(i - min)); + Constraint notToTakeInGroupCarrdinality = new MultiOrConstraint(); + for (int k=i+1;k<=max;k++){ + ((MultiOrConstraint)notToTakeInGroupCarrdinality).add_sub_part(new LiteralConstraint(newChildren.getFeatures().get(k - min))); + } + if (notToTakeInGroupCarrdinality.getConstraintSubParts().size() == 1) { + notToTakeInGroupCarrdinality = notToTakeInGroupCarrdinality.getConstraintSubParts().get(0); + } + Constraint groupCardinalityOrderConstraint = new ImplicationConstraint(new NotConstraint(lastTakenInGroupCardinality), new NotConstraint(notToTakeInGroupCarrdinality)); + featureModel.getOwnConstraints().add(groupCardinalityOrderConstraint); + } + feature.getChildren().removeAll(feature.getChildren()); + feature.getChildren().add(newChildren); + newChildren.setParentFeature(feature); + } + + private void addPrefixToNamesRecursively(Feature feature, String prefix) { + feature.setFeatureName(feature.getFeatureName() + prefix); + if (!feature.isSubmodelRoot()) { + for (Group group : feature.getChildren()) { + for (Feature subFeature : group.getFeatures()) { + addPrefixToNamesRecursively(subFeature, prefix); + } + } + } + } + + private List getConstraintsOnSubTree(FeatureModel featureModel, List subTreeFeatures) { + List constraints = new LinkedList<>(); + for (Constraint constraint : featureModel.getConstraints()) { + if (constraintContains(constraint, subTreeFeatures)) { + constraints.add(constraint); + featureModel.getOwnConstraints().remove(constraint); + } + } + return constraints; + } + + private List getFeatureFromSubTree(Group group) { + List features = new LinkedList<>(); + features.addAll(group.getFeatures()); + for (Feature subFeatures : group.getFeatures()) { + if (!subFeatures.isSubmodelRoot()) { + for (Group subGroup : subFeatures.getChildren()) { + features.addAll(getFeatureFromSubTree(subGroup)); + } + } + } + return features; + } + + private boolean constraintContains(Constraint constraint, List subTreeFeatures) { + List subParts = constraint.getConstraintSubParts(); + for (Constraint subPart : subParts) { + if (subPart instanceof LiteralConstraint && ((LiteralConstraint) subPart).getReference() instanceof Feature) { + Feature feature = (Feature) ((LiteralConstraint) subPart).getReference(); + if (subTreeFeatures.contains(feature)) { + return true; + } + } else { + constraintContains(subPart, subTreeFeatures); + } + } + return false; + } + + + private void createFeatureReplacementMap(Feature oldSubTree, Feature newSubTree, Map featureFeatureMap) { + featureFeatureMap.put(oldSubTree.getFeatureName(), newSubTree); + if (!oldSubTree.isSubmodelRoot()) { + for (int i = 0; i < oldSubTree.getChildren().size(); i++) { + for (int j = 0; j < oldSubTree.getChildren().get(i).getFeatures().size(); j++) { + createFeatureReplacementMap(oldSubTree.getChildren().get(i).getFeatures().get(j), newSubTree.getChildren().get(i).getFeatures().get(j), featureFeatureMap); + } + } + } + } + + private void adaptConstraint(Feature subTreeRoot, Constraint constraint, Map featureReplacementMap) { + List subParts = constraint.getConstraintSubParts(); + for (Constraint subPart : subParts) { + if (subPart instanceof LiteralConstraint) { + String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); + if (featureReplacementMap.containsKey(toReplace)) { + LiteralConstraint subTreeRootConstraint = new LiteralConstraint(subTreeRoot); + LiteralConstraint newLiteral = new LiteralConstraint(featureReplacementMap.get(toReplace)); + constraint.replaceConstraintSubPart(subPart, new ParenthesisConstraint(new ImplicationConstraint(subTreeRootConstraint, newLiteral))); + } + } else { + adaptConstraint(subTreeRoot, subPart, featureReplacementMap); + } + } + } +} From 5cbe351c3439101d8fe2fd6275d295238ddd8b41 Mon Sep 17 00:00:00 2001 From: Stefan Date: Mon, 4 Nov 2024 09:52:16 +0100 Subject: [PATCH 29/60] feat: encode aggregate functions and string constraints in pseudo-boolean --- src/main/java/de/vill/main/Eval.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index 44733a3..bbb615c 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -160,6 +160,10 @@ public static void uvlToOPB(File file) throws IOException { FeatureModel featureModel = loadUVLFeatureModelFromFile(file.toString()); ConvertFeatureCardinalityForOPB convertFeatureCardinalityForOPB = new ConvertFeatureCardinalityForOPB(); convertFeatureCardinalityForOPB.convertFeatureModel(featureModel); + Set levels = new HashSet<>(); + levels.add(LanguageLevel.AGGREGATE_FUNCTION); + levels.add( LanguageLevel.STRING_CONSTRAINTS); + uvlModelFactory.convertLanguageLevel(featureModel, levels); try (BufferedWriter writer = new BufferedWriter(new FileWriter(Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".opb").toString()))) { writer.append(featureModel.toOPBString()); writer.flush(); From a386eccfdb08ea1d477b36b694220325d08c2083 Mon Sep 17 00:00:00 2001 From: Stefan Date: Mon, 4 Nov 2024 10:32:36 +0100 Subject: [PATCH 30/60] fix: remove multi or in feature cardinality conversion --- .../util/ConvertFeatureCardinalityForOPB.java | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java b/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java index 5cf3655..03987da 100644 --- a/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java +++ b/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java @@ -57,14 +57,11 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel } for (int i = min; i < max; i++) { Constraint lastTakenInGroupCardinality = new LiteralConstraint(newChildren.getFeatures().get(i - min)); - Constraint notToTakeInGroupCarrdinality = new MultiOrConstraint(); + List notToTakeInGroupCarrdinality = new LinkedList<>(); for (int k=i+1;k<=max;k++){ - ((MultiOrConstraint)notToTakeInGroupCarrdinality).add_sub_part(new LiteralConstraint(newChildren.getFeatures().get(k - min))); + notToTakeInGroupCarrdinality.add(new LiteralConstraint(newChildren.getFeatures().get(k - min))); } - if (notToTakeInGroupCarrdinality.getConstraintSubParts().size() == 1) { - notToTakeInGroupCarrdinality = notToTakeInGroupCarrdinality.getConstraintSubParts().get(0); - } - Constraint groupCardinalityOrderConstraint = new ImplicationConstraint(new NotConstraint(lastTakenInGroupCardinality), new NotConstraint(notToTakeInGroupCarrdinality)); + Constraint groupCardinalityOrderConstraint = new ImplicationConstraint(new NotConstraint(lastTakenInGroupCardinality), new NotConstraint(createDisjunction(notToTakeInGroupCarrdinality))); featureModel.getOwnConstraints().add(groupCardinalityOrderConstraint); } feature.getChildren().removeAll(feature.getChildren()); @@ -72,6 +69,15 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel newChildren.setParentFeature(feature); } + private Constraint createDisjunction(List literals) { + if (literals.size() == 1) { + return literals.get(0); + } + LiteralConstraint literalConstraint = literals.get(0); + literals.remove(0); + return new OrConstraint(literalConstraint, createDisjunction(literals)); + } + private void addPrefixToNamesRecursively(Feature feature, String prefix) { feature.setFeatureName(feature.getFeatureName() + prefix); if (!feature.isSubmodelRoot()) { From 4b433a1a221497d4be9142358d7017d7bdacfc94 Mon Sep 17 00:00:00 2001 From: Stefan Date: Mon, 4 Nov 2024 11:40:31 +0100 Subject: [PATCH 31/60] fix: biimplication of literal and pb constraint (because former assumption that constraint is always >= does not hold for random uvl expressions) --- src/main/java/de/vill/model/pbc/Literal.java | 15 ++- .../java/de/vill/model/pbc/PBConstraint.java | 100 +++++++++++++++++- src/main/java/de/vill/util/Util.java | 40 +------ 3 files changed, 118 insertions(+), 37 deletions(-) diff --git a/src/main/java/de/vill/model/pbc/Literal.java b/src/main/java/de/vill/model/pbc/Literal.java index f201412..999df7e 100644 --- a/src/main/java/de/vill/model/pbc/Literal.java +++ b/src/main/java/de/vill/model/pbc/Literal.java @@ -1,6 +1,6 @@ package de.vill.model.pbc; -public class Literal { +public class Literal implements Cloneable{ public String name; public double factor; public Literal(){} @@ -8,4 +8,17 @@ public Literal(double factor, String name) { this.name = name; this.factor = factor; } + + @Override + public Literal clone() { + Literal literal = null; + try { + literal = (Literal) super.clone(); + } catch (CloneNotSupportedException e) { + literal = new Literal(); + literal.name = this.name; + literal.factor = this.factor; + } + return literal; + } } diff --git a/src/main/java/de/vill/model/pbc/PBConstraint.java b/src/main/java/de/vill/model/pbc/PBConstraint.java index 39f9922..653a2e0 100644 --- a/src/main/java/de/vill/model/pbc/PBConstraint.java +++ b/src/main/java/de/vill/model/pbc/PBConstraint.java @@ -1,8 +1,9 @@ package de.vill.model.pbc; +import java.util.LinkedList; import java.util.List; -public class PBConstraint { +public class PBConstraint implements Cloneable{ public List literalList; public double k; public PBConstraintType type; @@ -11,6 +12,85 @@ public PBConstraint() { type = PBConstraintType.GEQ; } + public PBConstraint negatedConstraint() { + PBConstraint newConstraint = (PBConstraint)clone(); + switch (type) { + case GEQ: + newConstraint.type = PBConstraintType.LE; + break; + case GE: + newConstraint.type = PBConstraintType.LEQ; + break; + case LEQ: + newConstraint.type = PBConstraintType.GE; + break; + case LE: + newConstraint.type = PBConstraintType.GEQ; + break; + case EQ: + newConstraint.type = PBConstraintType.NOTEQ; + break; + case NOTEQ: + newConstraint.type = PBConstraintType.EQ; + break; + } + return newConstraint; + } + + public List orWithLiteral(String literalName, boolean sign) { + PBConstraint newConstraint = (PBConstraint)clone(); + double f = this.k; + switch (type) { + case GEQ: + for (Literal l : this.literalList){ + f += Math.abs(l.factor); + } + break; + case GE: + for (Literal l : this.literalList){ + f += Math.abs(l.factor); + } + f++; + break; + case LEQ: + for (Literal l : this.literalList){ + f -= Math.abs(l.factor); + } + break; + case LE: + for (Literal l : this.literalList){ + f -= Math.abs(l.factor); + } + f--; + break; + case EQ: + PBConstraint c1 = clone(); + PBConstraint c2 = clone(); + c1.type = PBConstraintType.LEQ; + c2.type = PBConstraintType.GEQ; + List resultList = new LinkedList<>(); + resultList.addAll(c1.orWithLiteral(literalName, sign)); + resultList.addAll(c2.orWithLiteral(literalName, sign)); + return resultList; + case NOTEQ: + for (Literal l : this.literalList){ + f += Math.abs(l.factor); + } + f++; + break; + } + if (sign) { + newConstraint.literalList.add(new Literal(f, literalName)); + } else { + newConstraint.k -= f; + newConstraint.literalList.add(new Literal(-f, literalName)); + } + + List resultList = new LinkedList<>(); + resultList.add(newConstraint); + return resultList; + } + public void toOPBString(OPBResult result) { result.numberConstraints++; int maxDecimalPlaces = getMaxDecimalPlaces(); @@ -56,5 +136,23 @@ private int countDecimalPlaces(double value) { return 0; } } + + @Override + public PBConstraint clone() { + PBConstraint pbConstraint = null; + try { + pbConstraint = (PBConstraint) super.clone(); + } catch (CloneNotSupportedException e) { + pbConstraint = new PBConstraint(); + pbConstraint.type = this.type; + pbConstraint.k = this.k; + } + pbConstraint.literalList = new LinkedList<>(); + for (Literal l : this.literalList) { + pbConstraint.literalList.add(l.clone()); + } + + return pbConstraint; + } } diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 62a508e..b17f133 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -113,41 +113,11 @@ public static List transformImplicationMap (HashMap substitutionConstraint(PBConstraint constraint, String substitutionName) { List resultList = new LinkedList<>(); - //x <=> constraint - PBConstraint c2 = new PBConstraint(); - c2.literalList = new LinkedList<>(); - c2.k = constraint.k; - for(Literal lit : constraint.literalList){ - Literal l2 = new Literal(); - l2.factor = lit.factor; - l2.name = lit.name; - c2.literalList.add(l2); - } - - //-x v constraint - double f = Math.abs(constraint.k); - for(Literal lit : constraint.literalList){ - f += Math.abs(lit.factor); - } - Literal l1 = new Literal(); - l1.name = substitutionName; - l1.factor = -f; - constraint.k = constraint.k - f; - constraint.literalList.add(l1); - resultList.add(constraint); - - //x v -constraint - f = Math.abs(c2.k); - for(Literal lit : c2.literalList){ - f += Math.abs(lit.factor); - } - f *= -1; - c2.type = PBConstraintType.LE; - Literal l2 = new Literal(); - l2.name = substitutionName; - l2.factor = f; - c2.literalList.add(l2); - resultList.add(c2); + // x <=> constraint is the same as -x v constraint AND x v -constraint + // -x v constraint + resultList.addAll(constraint.orWithLiteral(substitutionName, false)); + // x v -constraint + resultList.addAll(constraint.negatedConstraint().orWithLiteral(substitutionName, true)); return resultList; } From 8d8c578adb8c35eeebc53f45f299acd2706b307a Mon Sep 17 00:00:00 2001 From: Stefan Date: Mon, 4 Nov 2024 12:45:00 +0100 Subject: [PATCH 32/60] fix: conversion strategy for feature attribute constraints only searches for expressions as direct constraints but not as expressions that are part of a normal constraint --- .../java/de/vill/conversion/ConvertSMTLevel.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/main/java/de/vill/conversion/ConvertSMTLevel.java b/src/main/java/de/vill/conversion/ConvertSMTLevel.java index ed65440..46f4eb9 100644 --- a/src/main/java/de/vill/conversion/ConvertSMTLevel.java +++ b/src/main/java/de/vill/conversion/ConvertSMTLevel.java @@ -35,9 +35,23 @@ public void convertFeatureModel(FeatureModel rootFeatureModel, FeatureModel feat } featureModel.getOwnConstraints().removeIf(x -> x instanceof ExpressionConstraint); featureModel.getOwnConstraints().addAll(replacements); + for (Constraint constraint : featureModel.getOwnConstraints()) { + convertConstraint(constraint); + } traverseFeatures(featureModel.getRootFeature()); } + private void convertConstraint(Constraint constraint) { + for (Constraint subConstraint : constraint.getConstraintSubParts()) { + if (subConstraint instanceof ExpressionConstraint) { + Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) subConstraint); + constraint.replaceConstraintSubPart(subConstraint, equationReplacement); + }else{ + convertConstraint(subConstraint); + } + } + } + private void replaceEquationInConstraint(Constraint constraint) { for (Constraint subConstraint : constraint.getConstraintSubParts()) { if (subConstraint instanceof ExpressionConstraint) { From 934a6e8fc9924707365454d8f6193132549eea40 Mon Sep 17 00:00:00 2001 From: Stefan Date: Tue, 5 Nov 2024 10:33:18 +0100 Subject: [PATCH 33/60] feat: changed or-group pseudo-boolean encoding to are more concise one (old one was not wrong) --- src/main/java/de/vill/model/Feature.java | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index f7c8ed7..6052456 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -398,16 +398,13 @@ public void toOPBString(OPBResult result) { result.numberConstraints += 2; break; case OR: - result.opbString.append(group.getFeatures().size()); - result.opbString.append(" * "); + result.opbString.append("-1 * "); result.opbString.append(getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ - result.opbString.append(" -1 * "); + result.opbString.append(" + "); result.opbString.append(child.getFeatureName().replace(" ", "_")); } - result.opbString.append(" <= "); - result.opbString.append(group.getFeatures().size() - 1); - result.opbString.append(";\n"); + result.opbString.append(" >= 0;\n"); result.numberConstraints++; result.opbString.append(group.getFeatures().size()); result.opbString.append(" * "); From 40ae056703d76c3d64df0a099feceb72688d828d Mon Sep 17 00:00:00 2001 From: Stefan Date: Mon, 11 Nov 2024 16:03:14 +0100 Subject: [PATCH 34/60] feat: removed unnecessary IO from dimacs encoding --- src/main/java/de/vill/main/Eval.java | 37 ++++++++++++++++++++++------ 1 file changed, 29 insertions(+), 8 deletions(-) diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index bbb615c..7d333b6 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -1,10 +1,13 @@ package de.vill.main; +import de.ovgu.featureide.fm.core.ExtensionManager; import de.ovgu.featureide.fm.core.base.IFeatureModel; import de.ovgu.featureide.fm.core.base.impl.*; import de.ovgu.featureide.fm.core.init.FMCoreLibrary; import de.ovgu.featureide.fm.core.init.LibraryManager; +import de.ovgu.featureide.fm.core.io.IPersistentFormat; +import de.ovgu.featureide.fm.core.io.Problem; import de.ovgu.featureide.fm.core.io.dimacs.DIMACSFormat; import de.ovgu.featureide.fm.core.io.manager.FeatureModelManager; import de.ovgu.featureide.fm.core.io.manager.FileHandler; @@ -31,7 +34,7 @@ public class Eval { public static final String P2D_PATH = "/home/stefan/p2d/target/release/p2d"; public static void main(String[] args) throws IOException, InterruptedException { - runSingleFile("test.uvl"); + runSingleFile("/models/automotive01.uvl"); //runEval(); } @@ -179,18 +182,36 @@ public static void uvlToDimacsFeatureIDE(File file) throws IOException { levels.add(LanguageLevel.BOOLEAN_LEVEL); levels.add( LanguageLevel.TYPE_LEVEL); uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); - try (BufferedWriter writer = new BufferedWriter(new FileWriter(Paths.get(WORKING_DIR, "tmp_files", file.getName() + "_sat_level.uvl").toString()))) { - writer.append(featureModel.toString()); - writer.flush(); - } catch (IOException e) { - System.err.println("Error writing to file: " + e.getMessage()); - } + LibraryManager.registerLibrary(FMCoreLibrary.getInstance()); FMFormatManager.getInstance().addExtension(new UVLFeatureModelFormat()); - IFeatureModel fm = FeatureModelManager.load(Paths.get(WORKING_DIR, "tmp_files", file.getName() + "_sat_level.uvl")); + + IFeatureModel fm = getFeatureIdeFMFromString(file.toPath(), featureModel.toString()); FileHandler.save(Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".dimacs"), fm, new DIMACSFormat()); } + + public static IFeatureModel getFeatureIdeFMFromString(Path path, String content) throws IOException { + final FileHandler fileHandler = new FileHandler<>(path, null, null); + final UVLFeatureModelFormat format = new UVLFeatureModelFormat(); + try { + final IFeatureModel fm = FMFactoryManager.getInstance().getFactory(path, format).create(); + fileHandler.setObject(fm); + fileHandler.setFormat(format); + format.getInstance().read(fm, content, path); + + }catch (ExtensionManager.NoSuchExtensionException e) { + throw new IOException("Error while parsing UVL model"); + } + return fileHandler.getObject(); + } + + + + + + + public static void uvlToDimacsZ3(String modelName) throws IOException { uvlToSMT2(modelName + ".uvl", modelName + ".smt2"); smt2ToDimacs(modelName + ".smt2", modelName + ".dimacs"); From 7e42d96c9397def771ced70752ff2a1bca33d024 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 21 Nov 2024 09:16:52 +0100 Subject: [PATCH 35/60] fix: fixed and refactored pbc encoding --- src/main/java/de/vill/main/Eval.java | 15 +- src/main/java/de/vill/model/Feature.java | 32 +- src/main/java/de/vill/model/FeatureModel.java | 26 +- .../vill/model/constraint/AndConstraint.java | 56 +--- .../de/vill/model/constraint/Constraint.java | 5 +- .../constraint/EquivalenceConstraint.java | 52 +-- .../constraint/ExpressionConstraint.java | 25 +- .../constraint/ImplicationConstraint.java | 50 +-- .../model/constraint/LiteralConstraint.java | 8 + .../model/constraint/MultiOrConstraint.java | 7 + .../vill/model/constraint/NotConstraint.java | 45 ++- .../vill/model/constraint/OrConstraint.java | 60 ++-- .../constraint/ParenthesisConstraint.java | 5 +- .../vill/model/expression/DivExpression.java | 6 +- .../vill/model/expression/MulExpression.java | 14 +- .../model/expression/NumberExpression.java | 2 +- src/main/java/de/vill/model/pbc/Literal.java | 5 +- .../vill/model/pbc/PBCLiteralConstraint.java | 19 ++ .../java/de/vill/model/pbc/PBConstraint.java | 13 +- .../vill/util/SubstitutionVariableIndex.java | 7 +- src/main/java/de/vill/util/Util.java | 308 +++++++----------- 21 files changed, 336 insertions(+), 424 deletions(-) create mode 100644 src/main/java/de/vill/model/pbc/PBCLiteralConstraint.java diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index 7d333b6..8ed34ed 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -34,10 +34,17 @@ public class Eval { public static final String P2D_PATH = "/home/stefan/p2d/target/release/p2d"; public static void main(String[] args) throws IOException, InterruptedException { - runSingleFile("/models/automotive01.uvl"); - //runEval(); + //runSingleFile("test.uvl"); + //bs("/test.uvl"); + runEval(); } + + public static void bs(String modelName)throws IOException, InterruptedException { + File file = Paths.get(WORKING_DIR, modelName).toFile(); + uvlToOPB(file); + runp2d(file); + } public static void runSingleFile(String modelName) throws IOException, InterruptedException { File file = Paths.get(WORKING_DIR, modelName).toFile(); ModelEvalResult result = evaluateModel(file); @@ -46,7 +53,7 @@ public static void runSingleFile(String modelName) throws IOException, Interrupt } public static void runEval() throws IOException, InterruptedException { - final int NUMBER_RUNS = 10; + final int NUMBER_RUNS = 3; List resultList = new LinkedList<>(); File folder = Paths.get(WORKING_DIR, "models").toFile(); File[] files = folder.listFiles(); @@ -81,7 +88,7 @@ public static void runEval() throws IOException, InterruptedException { public static ModelEvalResult evaluateModel(File file) throws IOException, InterruptedException { double totalTimeDimacs = 0; - final long NUMBER_RUNS = 1; + final long NUMBER_RUNS = 3; for (int i=0;i= 0;\n"); result.numberConstraints++; @@ -389,38 +389,38 @@ public void toOPBString(OPBResult result) { case MANDATORY: result.opbString.append(group.getFeatures().size()); result.opbString.append(" * "); - result.opbString.append(getFeatureName().replace(" ", "_")); + result.opbString.append("_" + getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append(child.getFeatureName().replace(" ", "_")); + result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); } result.opbString.append(" = 0;\n"); result.numberConstraints += 2; break; case OR: result.opbString.append("-1 * "); - result.opbString.append(getFeatureName().replace(" ", "_")); + result.opbString.append("_" + getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ result.opbString.append(" + "); - result.opbString.append(child.getFeatureName().replace(" ", "_")); + result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); } result.opbString.append(" >= 0;\n"); result.numberConstraints++; result.opbString.append(group.getFeatures().size()); result.opbString.append(" * "); - result.opbString.append(getFeatureName().replace(" ", "_")); + result.opbString.append("_" + getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append(child.getFeatureName().replace(" ", "_")); + result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); } result.opbString.append(" >= 0;\n"); result.numberConstraints++; break; case ALTERNATIVE: - result.opbString.append(getFeatureName()); + result.opbString.append("_" + getFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append(child.getFeatureName().replace(" ", "_")); + result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); } result.opbString.append(" = 0;\n"); result.numberConstraints += 2; @@ -428,10 +428,10 @@ public void toOPBString(OPBResult result) { case GROUP_CARDINALITY: result.opbString.append(group.getFeatures().size()); result.opbString.append(" * "); - result.opbString.append(getFeatureName().replace(" ", "_")); + result.opbString.append("_" + getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append(child.getFeatureName().replace(" ", "_")); + result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); } result.opbString.append(" >= 0;\n"); result.numberConstraints++; @@ -440,10 +440,10 @@ public void toOPBString(OPBResult result) { result.opbString.append("-"); result.opbString.append(group.getCardinality().lower); result.opbString.append(" * "); - result.opbString.append(getFeatureName().replace(" ", "_")); + result.opbString.append("_" + getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ result.opbString.append(" +1 * "); - result.opbString.append(child.getFeatureName().replace(" ", "_")); + result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); } result.opbString.append(" >= "); result.opbString.append(0); @@ -451,10 +451,10 @@ public void toOPBString(OPBResult result) { result.numberConstraints++; - result.opbString.append(getFeatureName().replace(" ", "_")); + result.opbString.append("_" + getFeatureName().replace(" ", "_")); for (Feature child : group.getFeatures()){ result.opbString.append(" +1 * "); - result.opbString.append(child.getFeatureName().replace(" ", "_")); + result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); } result.opbString.append(" <= "); result.opbString.append(group.getCardinality().upper + 1); diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 91a8d07..47e6df2 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -12,9 +12,11 @@ import de.vill.config.Configuration; import de.vill.model.constraint.Constraint; import de.vill.model.constraint.LiteralConstraint; +import de.vill.model.constraint.NotConstraint; import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; import de.vill.model.expression.LiteralExpression; +import de.vill.model.pbc.Literal; import de.vill.model.pbc.OPBResult; import de.vill.model.pbc.PBConstraint; import de.vill.util.SubstitutionVariableIndex; @@ -260,7 +262,7 @@ public String toString() { public StringBuilder toOPBString(){ OPBResult result = new OPBResult(); result.numberVariables++; - result.opbString.append(getRootFeature().getFeatureName().replace(" ", "_")); + result.opbString.append("_" + getRootFeature().getFeatureName().replace(" ", "_")); result.opbString.append(" >= 1;\n"); result.numberConstraints++; getRootFeature().toOPBString(result); @@ -272,11 +274,27 @@ public StringBuilder toOPBString(){ List additionalConstraints = new LinkedList<>(); for(Constraint constraint : constraints){ + if (constraint instanceof LiteralConstraint){ + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = 1; + Literal literal = new Literal(1, ((LiteralConstraint) constraint).getReference().getIdentifier(), true); + pbConstraint.literalList.add(literal); + result.numberVariables++; + pbConstraint.toOPBString(result); + continue; + } HashMap subMap = new HashMap<>(); - int n = 1; - constraint.extractTseitinSubConstraints(subMap, n, counter); + constraint.extractTseitinSubConstraints(subMap); var map = transformSubFormulas(subMap, additionalConstraints); - List pbcList = transformImplicationMap(map, counter); + List pbcList = transformImplicationMap(map); + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = 1; + boolean sign = !(constraint instanceof NotConstraint); + Literal literal = new Literal(1, "x_" + SubstitutionVariableIndex.getInstance().peekIndex(), sign); + pbConstraint.literalList.add(literal); + pbcList.add(pbConstraint); for(PBConstraint pBConstraint : pbcList){ result.numberVariables++; pBConstraint.toOPBString(result); diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index 313e4d7..2bc03c3 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -1,11 +1,13 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.PBCLiteralConstraint; +import de.vill.util.SubstitutionVariableIndex; import java.util.*; +import static de.vill.util.Util.getMaxAndConstraint; import static de.vill.util.Util.isJustAnd; -import static de.vill.util.Util.isJustOr; public class AndConstraint extends Constraint { private Constraint left; @@ -78,44 +80,20 @@ public List getReferences() { return references; } - public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { - int a1 = 0; - if(!isJustAnd(left) ){ - a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); - n += a1; - } - int a2 = 0; - if(!isJustAnd(right)){ - a2 = right.extractTseitinSubConstraints(substitutionMapping, n + 1, counter); - n+= a2; - } - int finalA = a1; - Constraint l1 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA; - } - }); - int finalA1 = a2; - Constraint l2 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA1; - } - }); - if(a1 == 0) { - l1 = left; - } - if(a2 == 0) { - l2 = right; - } - if (a1 + a2 != 0){ - n++; - } - - Constraint newConstraint = new AndConstraint(l1, l2); - substitutionMapping.put(n, newConstraint); - return n; + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + Constraint leftSub = getMaxAndConstraint(left, substitutionMapping); + Constraint rightSub = getMaxAndConstraint(right, substitutionMapping); + int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); + substitutionMapping.put(substitutionIndex, new AndConstraint(leftSub, rightSub)); + + return new PBCLiteralConstraint( + new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + substitutionIndex; + } + }) + ); } @Override diff --git a/src/main/java/de/vill/model/constraint/Constraint.java b/src/main/java/de/vill/model/constraint/Constraint.java index 915e93b..f3cc75c 100644 --- a/src/main/java/de/vill/model/constraint/Constraint.java +++ b/src/main/java/de/vill/model/constraint/Constraint.java @@ -2,6 +2,7 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCLiteralConstraint; import java.util.HashMap; import java.util.LinkedList; @@ -45,9 +46,7 @@ public int hashCode() { public abstract List getReferences(); - public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { - return 0; - }; + public abstract PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping); public StringBuilder toSMT2string(){ return null; diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index 888fb5b..8078942 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -1,6 +1,8 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.PBCLiteralConstraint; +import de.vill.util.SubstitutionVariableIndex; import java.util.*; @@ -79,40 +81,22 @@ public List getReferences() { return references; } - public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { - int a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); - n = n+a1; - int a2 = right.extractTseitinSubConstraints(substitutionMapping, n+1, counter); - n = n + a2; - - int finalA = a1; - Constraint l1 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA; - } - }); - int finalA1 = a2; - Constraint l2 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA1; - } - }); - if(a1 == 0) { - l1 = left; - } - if(a2 == 0) { - l2 = right; - } - if (a1 + a2 != 0){ - n++; - } - - Constraint newConstraint = new EquivalenceConstraint(l1, l2); - substitutionMapping.put(n, newConstraint); - return n; - }; + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + + Constraint leftSub = left.extractTseitinSubConstraints(substitutionMapping); + Constraint rightSub = right.extractTseitinSubConstraints(substitutionMapping); + int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); + substitutionMapping.put(substitutionIndex, new EquivalenceConstraint(leftSub, rightSub)); + + return new PBCLiteralConstraint( + new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + substitutionIndex; + } + }) + ); + } @Override public StringBuilder toSMT2string() { diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index 847d25d..79dbe50 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -6,6 +6,8 @@ import de.vill.model.expression.Expression; import de.vill.model.expression.LiteralExpression; import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCLiteralConstraint; +import de.vill.util.SubstitutionVariableIndex; import java.util.*; @@ -132,17 +134,16 @@ public List collectExpressions(){ } @Override - public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { - final int finalN = n; - Constraint l1 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalN; - } - }); - n++; - - substitutionMapping.put(n, this); - return n; + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); + substitutionMapping.put(substitutionIndex, this); + return new PBCLiteralConstraint( + new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + substitutionIndex; + } + }) + ); } } diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index 8d4bb4b..d5bbc67 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -1,6 +1,8 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.PBCLiteralConstraint; +import de.vill.util.SubstitutionVariableIndex; import java.util.*; @@ -79,39 +81,21 @@ public List getReferences() { return references; } - public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { - int a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); - n += a1; - int a2 = right.extractTseitinSubConstraints(substitutionMapping, n+1, counter); - n+= a2; - int finalA = a1; - Constraint l1 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA; - } - }); - int finalA1 = a2; - Constraint l2 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA1; - } - }); - if(a1 == 0) { - l1 = left; - } - if(a2 == 0) { - l2 = right; - } - if (a1 + a2 != 0){ - n++; - } - - Constraint newConstraint = new ImplicationConstraint(l1, l2); - substitutionMapping.put(n, newConstraint); - return n; - }; + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + Constraint leftSub = left.extractTseitinSubConstraints(substitutionMapping); + Constraint rightSub = right.extractTseitinSubConstraints(substitutionMapping); + int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); + substitutionMapping.put(substitutionIndex, new ImplicationConstraint(leftSub, rightSub)); + + return new PBCLiteralConstraint( + new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + substitutionIndex; + } + }) + ); + } @Override public StringBuilder toSMT2string() { diff --git a/src/main/java/de/vill/model/constraint/LiteralConstraint.java b/src/main/java/de/vill/model/constraint/LiteralConstraint.java index c5309c1..d98897f 100644 --- a/src/main/java/de/vill/model/constraint/LiteralConstraint.java +++ b/src/main/java/de/vill/model/constraint/LiteralConstraint.java @@ -1,10 +1,13 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.PBCLiteralConstraint; +import de.vill.util.SubstitutionVariableIndex; import de.vill.util.Util; import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Objects; public class LiteralConstraint extends Constraint { @@ -69,4 +72,9 @@ public StringBuilder toSMT2string() { builder.append(reference.getIdentifier()); return builder; } + + @Override + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + return new PBCLiteralConstraint(this); + } } diff --git a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java index b502b1a..7fd1cf7 100644 --- a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java +++ b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java @@ -1,6 +1,7 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.PBCLiteralConstraint; import java.util.*; @@ -93,6 +94,12 @@ public List getReferences() { return references; } + @Override + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + //TODO + return null; + } + @Override public StringBuilder toSMT2string() { StringBuilder builder = new StringBuilder(); diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index 493cca9..2f16cdf 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -1,6 +1,9 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.PBCLiteralConstraint; +import de.vill.util.SubstitutionVariableIndex; +import org.prop4j.Or; import java.util.*; @@ -68,31 +71,25 @@ public List getReferences() { return content.getReferences(); } - public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { - /* - if (content instanceof LiteralConstraint){ - return 0; - } - - */ - int a1 = content.extractTseitinSubConstraints(substitutionMapping, n, counter); - int finalA = a1; - Constraint l1 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA; - } - }); - if(a1 == 0) { - l1 = content; - }else{ - n = a1 + 1; - } + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + PBCLiteralConstraint subContent = content.extractTseitinSubConstraints(substitutionMapping); + //int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); + //substitutionMapping.put(substitutionIndex, new NotConstraint(subContent)); +/* + PBCLiteralConstraint result = new PBCLiteralConstraint( + new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + substitutionIndex; + } + }) + ); + result.toggleSign(); - Constraint newConstraint = new NotConstraint(l1); - substitutionMapping.put(n, newConstraint); - return n; - }; + */ + subContent.toggleSign(); + return subContent; + } @Override public StringBuilder toSMT2string() { diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index 003df0c..ab78465 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -1,11 +1,12 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.PBCLiteralConstraint; +import de.vill.util.SubstitutionVariableIndex; import java.util.*; -import static de.vill.util.Util.isJustAnd; -import static de.vill.util.Util.isJustOr; +import static de.vill.util.Util.*; public class OrConstraint extends Constraint { @@ -79,45 +80,22 @@ public List getReferences() { return references; } - public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { - int a1 = 0; - if(!isJustOr(left)){ - a1 = left.extractTseitinSubConstraints(substitutionMapping, n, counter); - n+= a1; - } - int a2 = 0; - if(!isJustOr(right)){ - a2 = right.extractTseitinSubConstraints(substitutionMapping, n, counter); - n += a2; - } - int finalA = a1; - Constraint l1 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA; - } - }); - int finalA1 = a2; - Constraint l2 = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + counter + "_" + finalA1; - } - }); - if(a1 == 0) { - l1 = left; - } - if(a2 == 0) { - l2 = right; - } - if (a1 + a2 != 0){ - n++; - } - - Constraint newConstraint = new OrConstraint(l1, l2); - substitutionMapping.put(n, newConstraint); - return n; - }; + @Override + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + Constraint leftSub = getMaxOrConstraint(left, substitutionMapping); + Constraint rightSub = getMaxOrConstraint(right, substitutionMapping); + int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); + substitutionMapping.put(substitutionIndex, new OrConstraint(leftSub, rightSub)); + + return new PBCLiteralConstraint( + new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return "x_" + substitutionIndex; + } + }) + ); + } @Override public StringBuilder toSMT2string() { diff --git a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java index 1a5bed4..bb4a3f6 100644 --- a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java +++ b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java @@ -1,6 +1,7 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; +import de.vill.model.pbc.PBCLiteralConstraint; import java.util.*; @@ -61,8 +62,8 @@ public List getReferences() { return content.getReferences(); } - public int extractTseitinSubConstraints(Map substitutionMapping, int n, int counter) { - return content.extractTseitinSubConstraints(substitutionMapping, n, counter); + public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { + return content.extractTseitinSubConstraints(substitutionMapping); }; @Override diff --git a/src/main/java/de/vill/model/expression/DivExpression.java b/src/main/java/de/vill/model/expression/DivExpression.java index f2e71e0..6d90934 100644 --- a/src/main/java/de/vill/model/expression/DivExpression.java +++ b/src/main/java/de/vill/model/expression/DivExpression.java @@ -3,8 +3,6 @@ import com.google.common.collect.Sets; import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.constraint.Constraint; -import de.vill.model.constraint.LiteralConstraint; import de.vill.model.pbc.Literal; import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; @@ -108,10 +106,10 @@ public List getAsSum(List additionalConstraints) { denominatorFactorSum += denominatorLiteral.factor; } newSummand.factor /= denominatorFactorSum; - newSummand.name = substitutionVariableIndex.getIndex(); + newSummand.name = substitutionVariableIndex.getSubName(); result.add(newSummand); PBConstraint denominatorConstraint = featureCombinationToPBConstraint(combination, denominatorSum); - denominatorConstraint.literalList.add(new Literal(1, l.name)); + denominatorConstraint.literalList.add(new Literal(1, l.name, true)); denominatorConstraint.k += 1; additionalConstraints.addAll(substitutionConstraint(denominatorConstraint, newSummand.name)); //TODO add x <=> l & combination (with positive and negative literals) diff --git a/src/main/java/de/vill/model/expression/MulExpression.java b/src/main/java/de/vill/model/expression/MulExpression.java index f72911f..8a785dc 100644 --- a/src/main/java/de/vill/model/expression/MulExpression.java +++ b/src/main/java/de/vill/model/expression/MulExpression.java @@ -113,7 +113,7 @@ public List getAsSum(List additionalConstraints) { }else { Literal l = new Literal(); l.factor = leftSum.get(i).factor * rightSum.get(j).factor; - l.name = substitutionVariableIndex.getIndex(); + l.name = substitutionVariableIndex.getSubName(); result.add(l); additionalConstraints.addAll(getSubstitutionConstraints(leftSum.get(i).name, rightSum.get(j).name, l.name)); } @@ -127,16 +127,16 @@ private List getSubstitutionConstraints(String a, String b, String PBConstraint PBConstraint1 = new PBConstraint(); PBConstraint1.literalList = new LinkedList<>(); PBConstraint1.k = 0; - PBConstraint1.literalList.add(new Literal(1, a)); - PBConstraint1.literalList.add(new Literal(1, b)); - PBConstraint1.literalList.add(new Literal(-2, c)); + PBConstraint1.literalList.add(new Literal(1, a, true)); + PBConstraint1.literalList.add(new Literal(1, b, true)); + PBConstraint1.literalList.add(new Literal(-2, c, true)); result.add(PBConstraint1); PBConstraint PBConstraint2 = new PBConstraint(); PBConstraint2.literalList = new LinkedList<>(); PBConstraint2.k = -1; - PBConstraint2.literalList.add(new Literal(-1, a)); - PBConstraint2.literalList.add(new Literal(-1, b)); - PBConstraint2.literalList.add(new Literal(2, c)); + PBConstraint2.literalList.add(new Literal(-1, a, true)); + PBConstraint2.literalList.add(new Literal(-1, b, true)); + PBConstraint2.literalList.add(new Literal(2, c, true)); result.add(PBConstraint2); return result; } diff --git a/src/main/java/de/vill/model/expression/NumberExpression.java b/src/main/java/de/vill/model/expression/NumberExpression.java index 3c304ad..0e5d3ef 100644 --- a/src/main/java/de/vill/model/expression/NumberExpression.java +++ b/src/main/java/de/vill/model/expression/NumberExpression.java @@ -87,7 +87,7 @@ public List getReferences() { @Override public List getAsSum(List additionalConstraints) { List result = new LinkedList<>(); - result.add(new Literal(number, null)); + result.add(new Literal(number, null, true)); return result; } diff --git a/src/main/java/de/vill/model/pbc/Literal.java b/src/main/java/de/vill/model/pbc/Literal.java index 999df7e..2fd6fa6 100644 --- a/src/main/java/de/vill/model/pbc/Literal.java +++ b/src/main/java/de/vill/model/pbc/Literal.java @@ -3,10 +3,12 @@ public class Literal implements Cloneable{ public String name; public double factor; + public boolean sign; public Literal(){} - public Literal(double factor, String name) { + public Literal(double factor, String name, boolean sign) { this.name = name; this.factor = factor; + this.sign = sign; } @Override @@ -18,6 +20,7 @@ public Literal clone() { literal = new Literal(); literal.name = this.name; literal.factor = this.factor; + literal.sign = this.sign; } return literal; } diff --git a/src/main/java/de/vill/model/pbc/PBCLiteralConstraint.java b/src/main/java/de/vill/model/pbc/PBCLiteralConstraint.java new file mode 100644 index 0000000..0c17402 --- /dev/null +++ b/src/main/java/de/vill/model/pbc/PBCLiteralConstraint.java @@ -0,0 +1,19 @@ +package de.vill.model.pbc; + +import de.vill.model.building.VariableReference; +import de.vill.model.constraint.LiteralConstraint; + +public class PBCLiteralConstraint extends LiteralConstraint { + public boolean sign = true; + public PBCLiteralConstraint(VariableReference reference) { + super(reference); + } + + public PBCLiteralConstraint(LiteralConstraint literalConstraint){ + super(literalConstraint.getReference()); + } + + public void toggleSign(){ + sign = !sign; + } +} diff --git a/src/main/java/de/vill/model/pbc/PBConstraint.java b/src/main/java/de/vill/model/pbc/PBConstraint.java index 653a2e0..1e2ebd4 100644 --- a/src/main/java/de/vill/model/pbc/PBConstraint.java +++ b/src/main/java/de/vill/model/pbc/PBConstraint.java @@ -80,10 +80,10 @@ public List orWithLiteral(String literalName, boolean sign) { break; } if (sign) { - newConstraint.literalList.add(new Literal(f, literalName)); + newConstraint.literalList.add(new Literal(f, literalName, true)); } else { newConstraint.k -= f; - newConstraint.literalList.add(new Literal(-f, literalName)); + newConstraint.literalList.add(new Literal(-f, literalName, true)); } List resultList = new LinkedList<>(); @@ -92,6 +92,13 @@ public List orWithLiteral(String literalName, boolean sign) { } public void toOPBString(OPBResult result) { + for (Literal l : literalList) { + if (!l.sign){ + k -= l.factor; + l.factor *= -1; + l.sign = !l.sign; + } + } result.numberConstraints++; int maxDecimalPlaces = getMaxDecimalPlaces(); for(Literal l : literalList){ @@ -103,7 +110,7 @@ public void toOPBString(OPBResult result) { result.opbString.append((long) (l.factor * Math.pow(10,maxDecimalPlaces))); } result.opbString.append(" "); - result.opbString.append(l.name); + result.opbString.append("_" + l.name); } result.opbString.append(" "); result.opbString.append(type); diff --git a/src/main/java/de/vill/util/SubstitutionVariableIndex.java b/src/main/java/de/vill/util/SubstitutionVariableIndex.java index d375a91..62b410d 100644 --- a/src/main/java/de/vill/util/SubstitutionVariableIndex.java +++ b/src/main/java/de/vill/util/SubstitutionVariableIndex.java @@ -14,11 +14,16 @@ public static SubstitutionVariableIndex getInstance() { return objectRef; } - public String getIndex() { + public String getSubName() { index++; return "sub_z_" + index; } + public int getIndex() { + index++; + return index; + } + public int peekIndex(){ return index; } diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index b17f133..ee02db4 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -4,6 +4,7 @@ import de.vill.model.constraint.*; import de.vill.model.expression.*; import de.vill.model.pbc.Literal; +import de.vill.model.pbc.PBCLiteralConstraint; import de.vill.model.pbc.PBConstraint; import de.vill.model.pbc.PBConstraintType; @@ -63,7 +64,7 @@ public static boolean isJustAnd(Constraint constraint){ return true; } if(constraint instanceof NotConstraint){ - return ((NotConstraint) constraint).getContent() instanceof LiteralConstraint; + return ((NotConstraint) constraint).getContent() instanceof LiteralConstraint; } if(constraint instanceof AndConstraint && isJustAnd(((AndConstraint) constraint).getLeft()) && isJustAnd(((AndConstraint) constraint).getRight())){ return true; @@ -71,6 +72,26 @@ public static boolean isJustAnd(Constraint constraint){ return false; } + public static Constraint getMaxAndConstraint(Constraint constraint, Map substitutionMapping) { + if (constraint instanceof AndConstraint){ + return new AndConstraint( + getMaxAndConstraint(((AndConstraint) constraint).getLeft(), substitutionMapping), + getMaxAndConstraint(((AndConstraint) constraint).getRight(), substitutionMapping )); + }else{ + return constraint.extractTseitinSubConstraints(substitutionMapping); + } + } + + public static Constraint getMaxOrConstraint(Constraint constraint, Map substitutionMapping) { + if (constraint instanceof OrConstraint){ + return new OrConstraint( + getMaxOrConstraint(((OrConstraint) constraint).getLeft(), substitutionMapping), + getMaxOrConstraint(((OrConstraint) constraint).getRight(), substitutionMapping )); + }else{ + return constraint.extractTseitinSubConstraints(substitutionMapping); + } + } + public static boolean isJustOr(Constraint constraint){ if(constraint instanceof ParenthesisConstraint){ return isJustOr(((ParenthesisConstraint) constraint).getContent()); @@ -87,27 +108,15 @@ public static boolean isJustOr(Constraint constraint){ return false; } - public static List transformImplicationMap (HashMap> implicationMap, int counter){ + public static List transformImplicationMap (HashMap> implicationMap){ List resultList = new LinkedList<>(); - int max = 0; for (Map.Entry> entry : implicationMap.entrySet()) { - int x = entry.getKey(); - if(x > max) { - max = x; - } + int index = entry.getKey(); for(PBConstraint constraint : entry.getValue()){ - resultList.addAll(substitutionConstraint(constraint, "x_" + counter + "_" + x)); + resultList.addAll(substitutionConstraint(constraint, "x_" + index)); } } - PBConstraint finalPBConstraint = new PBConstraint(); - finalPBConstraint.literalList = new LinkedList<>(); - Literal l = new Literal(); - l.factor = 1; - l.name = "x_" + counter + "_" + max; - finalPBConstraint.literalList.add(l); - finalPBConstraint.k = 1; - resultList.add(finalPBConstraint); return resultList; } @@ -132,6 +141,8 @@ public static HashMap> transformSubFormulas(HashMap< public static List transformSubFormula(Constraint constraint, List additionalConstraints){ List resultList = new LinkedList<>(); if(constraint instanceof NotConstraint){ + System.err.println("error"); + System.exit(1); resultList.add(transformNegLiteral((NotConstraint) constraint)); } else if (constraint instanceof ImplicationConstraint) { resultList.add(transformImplication((ImplicationConstraint) constraint)); @@ -143,7 +154,6 @@ else if (constraint instanceof AndConstraint) { } else if (constraint instanceof OrConstraint) { var orConstraint = transformOr((OrConstraint) constraint); - orConstraint.k = orConstraint.k + 1; resultList.add(orConstraint); } else if (constraint instanceof ExpressionConstraint) { @@ -165,170 +175,63 @@ public static PBConstraint transformNegLiteral(NotConstraint constraint){ } public static PBConstraint transformImplication(ImplicationConstraint constraint){ - Constraint c1 = constraint.getLeft(); - Constraint c2 = constraint.getRight(); + PBCLiteralConstraint c1 = (PBCLiteralConstraint) constraint.getLeft(); + PBCLiteralConstraint c2 = (PBCLiteralConstraint) constraint.getRight(); Literal l1 = new Literal(); Literal l2 = new Literal(); - if(c1 instanceof NotConstraint && c2 instanceof NotConstraint){ - l1.name = ((LiteralConstraint)(((NotConstraint) c1).getContent())).getReference().getIdentifier(); - l2.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); - l1.factor = 1; - l2.factor = -1; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = 0; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - return PBConstraint1; - }else if(c1 instanceof LiteralConstraint && c2 instanceof LiteralConstraint){ - l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); - l2.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); - l1.factor = -1; - l2.factor = 1; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = 0; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - return PBConstraint1; - }else if (c1 instanceof NotConstraint) { - l1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); - l1.factor = 1; - l2.name = ((LiteralConstraint) (c2)).getReference().getIdentifier(); - l2.factor = 1; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = 1; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - return PBConstraint1; - }else{ - l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); - l2.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); - l1.factor = -1; - l2.factor = -1; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = -1; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - return PBConstraint1; - } + + l1.name = c1.getReference().getIdentifier(); + l2.name = c2.getReference().getIdentifier(); + l1.factor = -1; + l2.factor = 1; + l1.sign = c1.sign; + l2.sign = c2.sign; + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = 0; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); + return PBConstraint1; + } public static List transformBiImplication(EquivalenceConstraint constraint){ - Constraint c1 = constraint.getLeft(); - Constraint c2 = constraint.getRight(); + PBCLiteralConstraint c1 = (PBCLiteralConstraint) constraint.getLeft(); + PBCLiteralConstraint c2 = (PBCLiteralConstraint) constraint.getRight(); Literal l1 = new Literal(); Literal l2 = new Literal(); - if(c1 instanceof NotConstraint && c2 instanceof NotConstraint){ - l1.name = ((LiteralConstraint)(((NotConstraint) c1).getContent())).getReference().getIdentifier(); - l2.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); - l1.factor = 1; - l2.factor = -1; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = 0; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - - Literal l1_1 = new Literal(); - Literal l2_1 = new Literal(); - l1_1.name = ((LiteralConstraint)(((NotConstraint) c1).getContent())).getReference().getIdentifier(); - l2_1.name = ((LiteralConstraint)(((NotConstraint) c2).getContent())).getReference().getIdentifier(); - l1_1.factor = -1; - l2_1.factor = 1; - PBConstraint PBConstraint2 = new PBConstraint(); - PBConstraint2.k = 0; - PBConstraint2.literalList = new LinkedList<>(); - PBConstraint2.literalList.add(l1_1); - PBConstraint2.literalList.add(l2_1); - - List constraintList = new LinkedList<>(); - constraintList.add(PBConstraint1); - constraintList.add(PBConstraint2); - return constraintList; - }else if(c1 instanceof LiteralConstraint && c2 instanceof LiteralConstraint){ - l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); - l2.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); - l1.factor = 1; - l2.factor = -1; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = 0; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - - Literal l1_1 = new Literal(); - Literal l2_1 = new Literal(); - l1_1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); - l2_1.name = ((LiteralConstraint)(c2)).getReference().getIdentifier(); - l1_1.factor = -1; - l2_1.factor = 1; - PBConstraint PBConstraint2 = new PBConstraint(); - PBConstraint2.k = 0; - PBConstraint2.literalList = new LinkedList<>(); - PBConstraint2.literalList.add(l1_1); - PBConstraint2.literalList.add(l2_1); - - List constraintList = new LinkedList<>(); - constraintList.add(PBConstraint1); - constraintList.add(PBConstraint2); - return constraintList; - }else if (c1 instanceof NotConstraint) { - l1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); - l1.factor = -1; - l2.name = ((LiteralConstraint) (c2)).getReference().getIdentifier(); - l2.factor = -1; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = -1; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - - Literal l1_1 = new Literal(); - l1_1.name = ((LiteralConstraint) (((NotConstraint) c1).getContent())).getReference().getIdentifier(); - l1_1.factor = 1; - Literal l2_1 = new Literal(); - l2_1.name = ((LiteralConstraint) c2).getReference().getIdentifier(); - l2_1.factor = 1; - PBConstraint PBConstraint2 = new PBConstraint(); - PBConstraint2.k = 1; - PBConstraint2.literalList = new LinkedList<>(); - PBConstraint2.literalList.add(l1_1); - PBConstraint2.literalList.add(l2_1); - List constraintList = new LinkedList<>(); - constraintList.add(PBConstraint1); - constraintList.add(PBConstraint2); - return constraintList; - }else{ - l1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); - l2.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); - l1.factor = 1; - l2.factor = 1; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = 1; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - - Literal l1_1 = new Literal(); - Literal l2_1 = new Literal(); - l1_1.name = ((LiteralConstraint)(c1)).getReference().getIdentifier(); - l2_1.name = ((LiteralConstraint) (((NotConstraint) c2).getContent())).getReference().getIdentifier(); - l1_1.factor = -1; - l2_1.factor = -1; - PBConstraint PBConstraint2 = new PBConstraint(); - PBConstraint2.k = -1; - PBConstraint2.literalList = new LinkedList<>(); - PBConstraint2.literalList.add(l1_1); - PBConstraint2.literalList.add(l2_1); - - List constraintList = new LinkedList<>(); - constraintList.add(PBConstraint1); - constraintList.add(PBConstraint2); - return constraintList; - } + + l1.name = c1.getReference().getIdentifier(); + l2.name = c2.getReference().getIdentifier(); + l1.factor = 1; + l2.factor = -1; + l1.sign = c1.sign; + l2.sign = c2.sign; + PBConstraint PBConstraint1 = new PBConstraint(); + PBConstraint1.k = 0; + PBConstraint1.literalList = new LinkedList<>(); + PBConstraint1.literalList.add(l1); + PBConstraint1.literalList.add(l2); + + Literal l1_1 = new Literal(); + Literal l2_1 = new Literal(); + l1_1.name = c1.getReference().getIdentifier(); + l2_1.name = c2.getReference().getIdentifier(); + l1_1.factor = -1; + l2_1.factor = 1; + l1_1.sign = c1.sign; + l2_1.sign = c2.sign; + PBConstraint PBConstraint2 = new PBConstraint(); + PBConstraint2.k = 0; + PBConstraint2.literalList = new LinkedList<>(); + PBConstraint2.literalList.add(l1_1); + PBConstraint2.literalList.add(l2_1); + + List constraintList = new LinkedList<>(); + constraintList.add(PBConstraint1); + constraintList.add(PBConstraint2); + return constraintList; + } public static PBConstraint transformAnd(Constraint constraint){ @@ -339,17 +242,25 @@ public static PBConstraint transformAnd(Constraint constraint){ PBConstraint1.literalList.addAll(PBConstraint2.literalList); return PBConstraint1; }else{ + LiteralConstraint c1; + boolean sign; + if (constraint instanceof PBCLiteralConstraint) { + c1 = (LiteralConstraint) constraint; + sign = ((PBCLiteralConstraint)constraint).sign; + }else if (constraint instanceof LiteralConstraint) { + c1 = (LiteralConstraint) constraint; + sign = true; + }else { + c1 = (LiteralConstraint) ((NotConstraint) constraint).getContent(); + sign = false; + } Literal l1 = new Literal(); PBConstraint PBConstraint = new PBConstraint(); - if(constraint instanceof NotConstraint){ - l1.name = ((LiteralConstraint)((NotConstraint) constraint).getContent()).getReference().getIdentifier(); - l1.factor = -1; - PBConstraint.k = 0; - }else{ - l1.name = ((LiteralConstraint)constraint).getReference().getIdentifier(); - l1.factor = 1; - PBConstraint.k = 1; - } + + l1.name = c1.getReference().getIdentifier(); + l1.factor = 1; + l1.sign = sign; + PBConstraint.k = 1; PBConstraint.literalList = new LinkedList<>(); PBConstraint.literalList.add(l1); @@ -361,21 +272,28 @@ public static PBConstraint transformOr(Constraint constraint){ if(constraint instanceof OrConstraint){ PBConstraint PBConstraint1 = transformOr(((OrConstraint) constraint).getLeft()); PBConstraint PBConstraint2 = transformOr(((OrConstraint) constraint).getRight()); - PBConstraint1.k = PBConstraint1.k + PBConstraint2.k; PBConstraint1.literalList.addAll(PBConstraint2.literalList); return PBConstraint1; - }else{ + }else { + LiteralConstraint c1; + boolean sign; + if (constraint instanceof PBCLiteralConstraint) { + c1 = (LiteralConstraint) constraint; + sign = ((PBCLiteralConstraint)constraint).sign;; + }else if (constraint instanceof LiteralConstraint) { + c1 = (LiteralConstraint) constraint; + sign = true; + }else { + c1 = (LiteralConstraint) ((NotConstraint) constraint).getContent(); + sign = false; + } Literal l1 = new Literal(); PBConstraint PBConstraint = new PBConstraint(); - if(constraint instanceof NotConstraint){ - l1.name = ((LiteralConstraint)((NotConstraint) constraint).getContent()).getReference().getIdentifier(); - l1.factor = -1; - PBConstraint.k = -1; - }else{ - l1.name = ((LiteralConstraint)constraint).getReference().getIdentifier(); - l1.factor = 1; - PBConstraint.k = 0; - } + + l1.name = c1.getReference().getIdentifier(); + l1.factor = 1; + l1.sign = sign; + PBConstraint.k = 1; PBConstraint.literalList = new LinkedList<>(); PBConstraint.literalList.add(l1); @@ -435,7 +353,7 @@ public static PBConstraint transformExpression(ExpressionConstraint constraint, pbConstraint.k = rightSum.stream().map(x -> x.factor).reduce(0.0, Double::sum); pbConstraint.literalList = new LinkedList<>(); for (Map.Entry e : literalMap.entrySet()) { - pbConstraint.literalList.add(new Literal(e.getValue(), e.getKey())); + pbConstraint.literalList.add(new Literal(e.getValue(), e.getKey(), true)); } return pbConstraint; From 85929d5f13bc35c50d6715f4c1af31780927f50c Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 21 Nov 2024 10:04:44 +0100 Subject: [PATCH 36/60] fix: fixed pbc encoding for single negated literal constraints --- src/main/java/de/vill/model/FeatureModel.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 47e6df2..14d3f30 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -286,6 +286,29 @@ public StringBuilder toOPBString(){ } HashMap subMap = new HashMap<>(); constraint.extractTseitinSubConstraints(subMap); + + if (subMap.isEmpty()) { + if (constraint instanceof LiteralConstraint){ + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = 1; + Literal literal = new Literal(1, ((LiteralConstraint) constraint).getReference().getIdentifier(), true); + pbConstraint.literalList.add(literal); + result.numberVariables++; + pbConstraint.toOPBString(result); + continue; + }else if(constraint instanceof NotConstraint){ + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = 0; + Literal literal = new Literal(-1, ((LiteralConstraint)((NotConstraint)constraint).getContent()).getReference().getIdentifier(), true); + pbConstraint.literalList.add(literal); + result.numberVariables++; + pbConstraint.toOPBString(result); + continue; + } + } + var map = transformSubFormulas(subMap, additionalConstraints); List pbcList = transformImplicationMap(map); PBConstraint pbConstraint = new PBConstraint(); From 3c4adc1cfc2fe01fc805aefc946d24b753b3f0b1 Mon Sep 17 00:00:00 2001 From: Stefan Date: Sat, 23 Nov 2024 11:25:10 +0100 Subject: [PATCH 37/60] fix: simplified and fixed opb encoding --- src/main/java/de/vill/util/Util.java | 60 +++++++--------------------- 1 file changed, 15 insertions(+), 45 deletions(-) diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index ee02db4..2be144a 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -147,7 +147,7 @@ public static List transformSubFormula(Constraint constraint, List } else if (constraint instanceof ImplicationConstraint) { resultList.add(transformImplication((ImplicationConstraint) constraint)); } else if (constraint instanceof EquivalenceConstraint) { - resultList.addAll(transformBiImplication((EquivalenceConstraint) constraint)); + resultList.add(transformBiImplication((EquivalenceConstraint) constraint)); } else if (constraint instanceof AndConstraint) { resultList.add(transformAnd((AndConstraint) constraint)); @@ -177,60 +177,30 @@ public static PBConstraint transformNegLiteral(NotConstraint constraint){ public static PBConstraint transformImplication(ImplicationConstraint constraint){ PBCLiteralConstraint c1 = (PBCLiteralConstraint) constraint.getLeft(); PBCLiteralConstraint c2 = (PBCLiteralConstraint) constraint.getRight(); - Literal l1 = new Literal(); - Literal l2 = new Literal(); - - l1.name = c1.getReference().getIdentifier(); - l2.name = c2.getReference().getIdentifier(); - l1.factor = -1; - l2.factor = 1; - l1.sign = c1.sign; - l2.sign = c2.sign; + Literal l1 = new Literal(-1, c1.getReference().getIdentifier(), c1.sign); + Literal l2 = new Literal(1, c2.getReference().getIdentifier(), c2.sign); + PBConstraint PBConstraint1 = new PBConstraint(); PBConstraint1.k = 0; - PBConstraint1.literalList = new LinkedList<>(); PBConstraint1.literalList.add(l1); PBConstraint1.literalList.add(l2); return PBConstraint1; - } - public static List transformBiImplication(EquivalenceConstraint constraint){ + public static PBConstraint transformBiImplication(EquivalenceConstraint constraint){ PBCLiteralConstraint c1 = (PBCLiteralConstraint) constraint.getLeft(); PBCLiteralConstraint c2 = (PBCLiteralConstraint) constraint.getRight(); - Literal l1 = new Literal(); - Literal l2 = new Literal(); - - l1.name = c1.getReference().getIdentifier(); - l2.name = c2.getReference().getIdentifier(); - l1.factor = 1; - l2.factor = -1; - l1.sign = c1.sign; - l2.sign = c2.sign; - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = 0; - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); + Literal l1 = new Literal(1, c1.getReference().getIdentifier(), c1.sign); + Literal l2 = new Literal(-1, c2.getReference().getIdentifier(), c2.sign); - Literal l1_1 = new Literal(); - Literal l2_1 = new Literal(); - l1_1.name = c1.getReference().getIdentifier(); - l2_1.name = c2.getReference().getIdentifier(); - l1_1.factor = -1; - l2_1.factor = 1; - l1_1.sign = c1.sign; - l2_1.sign = c2.sign; - PBConstraint PBConstraint2 = new PBConstraint(); - PBConstraint2.k = 0; - PBConstraint2.literalList = new LinkedList<>(); - PBConstraint2.literalList.add(l1_1); - PBConstraint2.literalList.add(l2_1); - - List constraintList = new LinkedList<>(); - constraintList.add(PBConstraint1); - constraintList.add(PBConstraint2); - return constraintList; + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.k = 0; + pbConstraint.type = PBConstraintType.EQ; + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.literalList.add(l1); + pbConstraint.literalList.add(l2); + + return pbConstraint; } From d983695f0ebe993501536b7ed2d31188913c479f Mon Sep 17 00:00:00 2001 From: Stefan Date: Sat, 23 Nov 2024 11:25:33 +0100 Subject: [PATCH 38/60] refactor: simplified PBConstraint --- src/main/java/de/vill/model/pbc/PBConstraint.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/de/vill/model/pbc/PBConstraint.java b/src/main/java/de/vill/model/pbc/PBConstraint.java index 1e2ebd4..13cf389 100644 --- a/src/main/java/de/vill/model/pbc/PBConstraint.java +++ b/src/main/java/de/vill/model/pbc/PBConstraint.java @@ -10,6 +10,7 @@ public class PBConstraint implements Cloneable{ public PBConstraint() { type = PBConstraintType.GEQ; + literalList = new LinkedList<>(); } public PBConstraint negatedConstraint() { @@ -110,7 +111,7 @@ public void toOPBString(OPBResult result) { result.opbString.append((long) (l.factor * Math.pow(10,maxDecimalPlaces))); } result.opbString.append(" "); - result.opbString.append("_" + l.name); + result.opbString.append("\"" + l.name + "\""); } result.opbString.append(" "); result.opbString.append(type); From 7c8397babd5a658dfde3a648dc55ccdd16fa0f1b Mon Sep 17 00:00:00 2001 From: Stefan Date: Sat, 23 Nov 2024 11:25:48 +0100 Subject: [PATCH 39/60] refactor: default value for literal sign --- src/main/java/de/vill/model/pbc/Literal.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/de/vill/model/pbc/Literal.java b/src/main/java/de/vill/model/pbc/Literal.java index 2fd6fa6..5364d55 100644 --- a/src/main/java/de/vill/model/pbc/Literal.java +++ b/src/main/java/de/vill/model/pbc/Literal.java @@ -3,7 +3,7 @@ public class Literal implements Cloneable{ public String name; public double factor; - public boolean sign; + public boolean sign = true; public Literal(){} public Literal(double factor, String name, boolean sign) { this.name = name; From 6fcf9207e07e966b8b94a516cedbac0b7638ad84 Mon Sep 17 00:00:00 2001 From: Stefan Date: Sat, 23 Nov 2024 11:26:33 +0100 Subject: [PATCH 40/60] refactor: escape every feature name with " to avoid errors with solver (e.g. for - in name) --- src/main/java/de/vill/model/FeatureModel.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 14d3f30..3e2b4e2 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -262,7 +262,7 @@ public String toString() { public StringBuilder toOPBString(){ OPBResult result = new OPBResult(); result.numberVariables++; - result.opbString.append("_" + getRootFeature().getFeatureName().replace(" ", "_")); + result.opbString.append(getRootFeature().getQuotedFeatureName()); result.opbString.append(" >= 1;\n"); result.numberConstraints++; getRootFeature().toOPBString(result); From 2b1cfe12f6bcce013010f6b5d835ba49f426b0a5 Mon Sep 17 00:00:00 2001 From: Stefan Date: Sat, 23 Nov 2024 11:26:43 +0100 Subject: [PATCH 41/60] refactor: escape every feature name with " to avoid errors with solver (e.g. for - in name) --- src/main/java/de/vill/model/Feature.java | 35 +++++++++++++----------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index 69cda24..6307edb 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -371,6 +371,9 @@ public String toString() { return toString(true, ""); } + public String getQuotedFeatureName(){ + return "\"" + getFeatureName() + "\""; + } public void toOPBString(OPBResult result) { List childGroups = getChildren(); for (Group group : childGroups){ @@ -378,10 +381,10 @@ public void toOPBString(OPBResult result) { case OPTIONAL: result.opbString.append(group.getFeatures().size()); result.opbString.append(" * "); - result.opbString.append("_" + getFeatureName().replace(" ", "_")); + result.opbString.append(getQuotedFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); + result.opbString.append(child.getQuotedFeatureName()); } result.opbString.append(" >= 0;\n"); result.numberConstraints++; @@ -389,38 +392,38 @@ public void toOPBString(OPBResult result) { case MANDATORY: result.opbString.append(group.getFeatures().size()); result.opbString.append(" * "); - result.opbString.append("_" + getFeatureName().replace(" ", "_")); + result.opbString.append(getQuotedFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); + result.opbString.append(child.getQuotedFeatureName()); } result.opbString.append(" = 0;\n"); result.numberConstraints += 2; break; case OR: result.opbString.append("-1 * "); - result.opbString.append("_" + getFeatureName().replace(" ", "_")); + result.opbString.append(getQuotedFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" + "); - result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); + result.opbString.append(child.getQuotedFeatureName()); } result.opbString.append(" >= 0;\n"); result.numberConstraints++; result.opbString.append(group.getFeatures().size()); result.opbString.append(" * "); - result.opbString.append("_" + getFeatureName().replace(" ", "_")); + result.opbString.append(getQuotedFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); + result.opbString.append(child.getQuotedFeatureName()); } result.opbString.append(" >= 0;\n"); result.numberConstraints++; break; case ALTERNATIVE: - result.opbString.append("_" + getFeatureName()); + result.opbString.append(getQuotedFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); + result.opbString.append(child.getQuotedFeatureName()); } result.opbString.append(" = 0;\n"); result.numberConstraints += 2; @@ -428,10 +431,10 @@ public void toOPBString(OPBResult result) { case GROUP_CARDINALITY: result.opbString.append(group.getFeatures().size()); result.opbString.append(" * "); - result.opbString.append("_" + getFeatureName().replace(" ", "_")); + result.opbString.append(getQuotedFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" -1 * "); - result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); + result.opbString.append(child.getQuotedFeatureName()); } result.opbString.append(" >= 0;\n"); result.numberConstraints++; @@ -440,10 +443,10 @@ public void toOPBString(OPBResult result) { result.opbString.append("-"); result.opbString.append(group.getCardinality().lower); result.opbString.append(" * "); - result.opbString.append("_" + getFeatureName().replace(" ", "_")); + result.opbString.append(getQuotedFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" +1 * "); - result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); + result.opbString.append(child.getQuotedFeatureName()); } result.opbString.append(" >= "); result.opbString.append(0); @@ -451,10 +454,10 @@ public void toOPBString(OPBResult result) { result.numberConstraints++; - result.opbString.append("_" + getFeatureName().replace(" ", "_")); + result.opbString.append(getQuotedFeatureName()); for (Feature child : group.getFeatures()){ result.opbString.append(" +1 * "); - result.opbString.append("_" + child.getFeatureName().replace(" ", "_")); + result.opbString.append(child.getQuotedFeatureName()); } result.opbString.append(" <= "); result.opbString.append(group.getCardinality().upper + 1); From cadc16c4796f3fd9c3211fd4010d77517a5da526 Mon Sep 17 00:00:00 2001 From: Stefan Date: Sat, 23 Nov 2024 11:27:19 +0100 Subject: [PATCH 42/60] fix: feature cardinality conversion strategy (set right constraint replacement, like described in UVL BA) --- .../conversion/ConvertFeatureCardinality.java | 11 ++++++----- .../util/ConvertFeatureCardinalityForOPB.java | 16 +++++++++++----- 2 files changed, 17 insertions(+), 10 deletions(-) diff --git a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java index dae088e..ae79587 100644 --- a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java +++ b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java @@ -71,8 +71,10 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel constraintReplacementMap.remove(feature.getFeatureName()); for (Constraint constraint : constraintsToClone) { Constraint newConstraint = constraint.clone(); - featureModel.getOwnConstraints().add(newConstraint); adaptConstraint(subTreeClone, newConstraint, constraintReplacementMap); + LiteralConstraint subTreeRootConstraint = new LiteralConstraint(newChild); + newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newConstraint)); + featureModel.getOwnConstraints().add(newConstraint); } } } @@ -124,8 +126,8 @@ private boolean constraintContains(Constraint constraint, List subTreeF if (subTreeFeatures.contains(feature)) { return true; } - } else { - constraintContains(subPart, subTreeFeatures); + } else if (constraintContains(subPart, subTreeFeatures)){ + return true; } } return false; @@ -149,9 +151,8 @@ private void adaptConstraint(Feature subTreeRoot, Constraint constraint, Map notToTakeInGroupCarrdinality = new LinkedList<>(); for (int k=i+1;k<=max;k++){ @@ -122,7 +125,10 @@ private boolean constraintContains(Constraint constraint, List subTreeF return true; } } else { - constraintContains(subPart, subTreeFeatures); + if (constraintContains(subPart, subTreeFeatures)) { + return true; + } + } } return false; @@ -148,7 +154,7 @@ private void adaptConstraint(Feature subTreeRoot, Constraint constraint, Map Date: Sat, 23 Nov 2024 15:26:07 +0100 Subject: [PATCH 43/60] fix: several bugs and added new semantic for constraints containing cloned features --- .../conversion/ConvertFeatureCardinality.java | 74 ++++++++++++++++--- 1 file changed, 64 insertions(+), 10 deletions(-) diff --git a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java index ae79587..581fc11 100644 --- a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java +++ b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java @@ -1,10 +1,7 @@ package de.vill.conversion; import de.vill.model.*; -import de.vill.model.constraint.Constraint; -import de.vill.model.constraint.ImplicationConstraint; -import de.vill.model.constraint.LiteralConstraint; -import de.vill.model.constraint.ParenthesisConstraint; +import de.vill.model.constraint.*; import java.util.*; @@ -52,6 +49,7 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel for (int i = min; i <= max; i++) { Feature newChild = new Feature(feature.getFeatureName() + "-" + i); + featureModel.getFeatureMap().put(newChild.getFeatureName(), newChild); newChild.getAttributes().put("abstract", new Attribute("abstract", true, feature)); newChildren.getFeatures().add(newChild); newChild.setParentGroup(newChildren); @@ -62,7 +60,7 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel } for (int j = 1; j <= i; j++) { Feature subTreeClone = feature.clone(); - addPrefixToNamesRecursively(subTreeClone, "-" + i + "-" + j); + addPrefixToNamesRecursively(subTreeClone, "-" + i + "-" + j, featureModel); mandatoryGroup.getFeatures().add(subTreeClone); subTreeClone.setParentGroup(mandatoryGroup); @@ -71,24 +69,73 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel constraintReplacementMap.remove(feature.getFeatureName()); for (Constraint constraint : constraintsToClone) { Constraint newConstraint = constraint.clone(); - adaptConstraint(subTreeClone, newConstraint, constraintReplacementMap); - LiteralConstraint subTreeRootConstraint = new LiteralConstraint(newChild); - newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newConstraint)); + if (newConstraint instanceof LiteralConstraint) { + String toReplace = ((LiteralConstraint) newConstraint).getReference().getIdentifier(); + if (constraintReplacementMap.containsKey(toReplace)) { + LiteralConstraint newLiteral = new LiteralConstraint(constraintReplacementMap.get(toReplace)); + LiteralConstraint subTreeRootConstraint = new LiteralConstraint(newChild); + newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newLiteral));; + } + }else{ + adaptConstraint(subTreeClone, newConstraint, constraintReplacementMap); + LiteralConstraint subTreeRootConstraint = new LiteralConstraint(newChild); + newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newConstraint)); + } featureModel.getOwnConstraints().add(newConstraint); } } } + + Set allFeatureNamesInSubTree = new HashSet<>(); + getAllSubFeatureNamesRecursively(feature, allFeatureNamesInSubTree); + for (Constraint constraint : constraintsToClone) { + Constraint newConstraint = constraint.clone(); + orAdaptedConstraint(newConstraint, allFeatureNamesInSubTree, min, max, featureModel); + featureModel.getOwnConstraints().add(newConstraint); + } + + feature.getChildren().removeAll(feature.getChildren()); feature.getChildren().add(newChildren); newChildren.setParentFeature(feature); } - private void addPrefixToNamesRecursively(Feature feature, String prefix) { + private void orAdaptedConstraint(Constraint constraint, Set featuresToReplace, int min, int max, FeatureModel featureModel) { + for (Constraint subPart : constraint.getConstraintSubParts()) { + if (subPart instanceof LiteralConstraint) { + String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); + if (featuresToReplace.contains(toReplace)){ + Feature f = featureModel.getFeatureMap().get(toReplace + "-" + min + "-1"); + Constraint newOr = new LiteralConstraint(f); + for (int i = min + 1; i <= max; i++) { + for (int j = 1; j <= i; j++) { + newOr = new OrConstraint(newOr, new LiteralConstraint(featureModel.getFeatureMap().get(toReplace + "-" + i + "-" + j))); + } + } + constraint.replaceConstraintSubPart(subPart, new ParenthesisConstraint(newOr)); + } + }else { + orAdaptedConstraint(subPart, featuresToReplace, min, max, featureModel); + } + } + } + + private void getAllSubFeatureNamesRecursively(Feature feature, Set names) { + names.add(feature.getFeatureName()); + for (Group child : feature.getChildren()) { + for(Feature childFeature : child.getFeatures()){ + getAllSubFeatureNamesRecursively(childFeature, names); + } + } + } + + private void addPrefixToNamesRecursively(Feature feature, String prefix, FeatureModel featureModel) { feature.setFeatureName(feature.getFeatureName() + prefix); + featureModel.getFeatureMap().put(feature.getFeatureName(), feature); if (!feature.isSubmodelRoot()) { for (Group group : feature.getChildren()) { for (Feature subFeature : group.getFeatures()) { - addPrefixToNamesRecursively(subFeature, prefix); + addPrefixToNamesRecursively(subFeature, prefix, featureModel); } } } @@ -120,6 +167,13 @@ private List getFeatureFromSubTree(Group group) { private boolean constraintContains(Constraint constraint, List subTreeFeatures) { List subParts = constraint.getConstraintSubParts(); + if (constraint instanceof LiteralConstraint && ((LiteralConstraint) constraint).getReference() instanceof Feature) { + Feature feature = (Feature) ((LiteralConstraint) constraint).getReference(); + if (subTreeFeatures.contains(feature)) { + return true; + } + } + for (Constraint subPart : subParts) { if (subPart instanceof LiteralConstraint && ((LiteralConstraint) subPart).getReference() instanceof Feature) { Feature feature = (Feature) ((LiteralConstraint) subPart).getReference(); From 772a08f9dd050f5d1ecc0e765f1baa5d847508ea Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 28 Nov 2024 08:28:18 +0100 Subject: [PATCH 44/60] fix: attribute cloning, remove unnecessary attributes for cloned feature cardinality subtree roots, expression contains feature from feature cardinality, unsatisfiable expression should return false and not throw error, several issues with opb division encoding, removed unnecessary overwrites of left and right in expression constraints, force order of featurecardinality and aggregate function conversion, several to string methods for better debugging, issues with whole number encoding because numbers get larger than long value, uniform substitution, simpler substitution code, --- .../conversion/ConvertFeatureCardinality.java | 77 +++++++-- .../de/vill/conversion/ConvertSMTLevel.java | 44 +++-- .../java/de/vill/main/UVLModelFactory.java | 19 +-- src/main/java/de/vill/model/Attribute.java | 17 +- src/main/java/de/vill/model/Feature.java | 4 +- src/main/java/de/vill/model/FeatureModel.java | 15 +- .../java/de/vill/model/LanguageLevel.java | 8 +- .../constraint/EqualEquationConstraint.java | 10 +- .../GreaterEqualsEquationConstraint.java | 11 +- .../constraint/GreaterEquationConstraint.java | 11 +- .../LowerEqualsEquationConstraint.java | 7 +- .../constraint/LowerEquationConstraint.java | 7 +- .../NotEqualsEquationConstraint.java | 7 +- .../vill/model/expression/AddExpression.java | 12 +- .../AggregateFunctionExpression.java | 13 +- .../vill/model/expression/DivExpression.java | 54 ++++--- .../de/vill/model/expression/Expression.java | 7 +- .../LengthAggregateFunctionExpression.java | 7 +- .../model/expression/LiteralExpression.java | 7 +- .../vill/model/expression/MulExpression.java | 16 +- .../model/expression/NumberExpression.java | 7 +- .../expression/ParenthesisExpression.java | 9 +- .../model/expression/StringExpression.java | 7 +- .../vill/model/expression/SubExpression.java | 11 +- src/main/java/de/vill/model/pbc/Literal.java | 9 ++ .../java/de/vill/model/pbc/PBConstraint.java | 14 ++ .../util/ConvertFeatureCardinalityForOPB.java | 152 +++++++++++++++--- .../vill/util/SubstitutionVariableIndex.java | 2 +- src/main/java/de/vill/util/Util.java | 43 +++-- 29 files changed, 426 insertions(+), 181 deletions(-) diff --git a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java index 581fc11..6855dd3 100644 --- a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java +++ b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java @@ -2,6 +2,8 @@ import de.vill.model.*; import de.vill.model.constraint.*; +import de.vill.model.expression.Expression; +import de.vill.model.expression.LiteralExpression; import java.util.*; @@ -60,6 +62,8 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel } for (int j = 1; j <= i; j++) { Feature subTreeClone = feature.clone(); + subTreeClone.getAttributes().clear(); + subTreeClone.getAttributes().put("abstract", new Attribute("abstract", true, subTreeClone)); addPrefixToNamesRecursively(subTreeClone, "-" + i + "-" + j, featureModel); mandatoryGroup.getFeatures().add(subTreeClone); subTreeClone.setParentGroup(mandatoryGroup); @@ -85,7 +89,8 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel } } } - +/* +additional constraint with all cloned versions ored Set allFeatureNamesInSubTree = new HashSet<>(); getAllSubFeatureNamesRecursively(feature, allFeatureNamesInSubTree); for (Constraint constraint : constraintsToClone) { @@ -94,6 +99,8 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel featureModel.getOwnConstraints().add(newConstraint); } + */ + feature.getChildren().removeAll(feature.getChildren()); feature.getChildren().add(newChildren); @@ -105,7 +112,7 @@ private void orAdaptedConstraint(Constraint constraint, Set featuresToRe if (subPart instanceof LiteralConstraint) { String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); if (featuresToReplace.contains(toReplace)){ - Feature f = featureModel.getFeatureMap().get(toReplace + "-" + min + "-1"); + Feature f = featureModel.getFeatureMap().get(toReplace + "-" + (min == 0 ? 1 : min) + "-1"); Constraint newOr = new LiteralConstraint(f); for (int i = min + 1; i <= max; i++) { for (int j = 1; j <= i; j++) { @@ -131,6 +138,7 @@ private void getAllSubFeatureNamesRecursively(Feature feature, Set names private void addPrefixToNamesRecursively(Feature feature, String prefix, FeatureModel featureModel) { feature.setFeatureName(feature.getFeatureName() + prefix); + var attributes = feature.getAttributes(); featureModel.getFeatureMap().put(feature.getFeatureName(), feature); if (!feature.isSubmodelRoot()) { for (Group group : feature.getChildren()) { @@ -172,6 +180,10 @@ private boolean constraintContains(Constraint constraint, List subTreeF if (subTreeFeatures.contains(feature)) { return true; } + }else if (constraint instanceof ExpressionConstraint) { + Expression left = ((ExpressionConstraint) constraint).getLeft(); + Expression right = ((ExpressionConstraint) constraint).getRight(); + return expressionContains(left,subTreeFeatures) || expressionContains(right,subTreeFeatures); } for (Constraint subPart : subParts) { @@ -187,6 +199,27 @@ private boolean constraintContains(Constraint constraint, List subTreeF return false; } + private boolean expressionContains(Expression expression, List subTreeFeatures) { + if (expression instanceof LiteralExpression) { + Feature feature = (Feature) ((Attribute) ((LiteralExpression) expression).getContent()).getFeature(); + if (subTreeFeatures.contains(feature)) { + return true; + } + } + + for (Expression subExpression : expression.getExpressionSubParts()) { + if (expression instanceof LiteralExpression) { + Feature feature = (Feature) ((LiteralExpression) expression).getContent(); + if (subTreeFeatures.contains(feature)) { + return true; + } + }else if(expressionContains(subExpression, subTreeFeatures)){ + return true; + } + } + return false; + } + private void createFeatureReplacementMap(Feature oldSubTree, Feature newSubTree, Map featureFeatureMap) { featureFeatureMap.put(oldSubTree.getFeatureName(), newSubTree); @@ -200,16 +233,38 @@ private void createFeatureReplacementMap(Feature oldSubTree, Feature newSubTree, } private void adaptConstraint(Feature subTreeRoot, Constraint constraint, Map featureReplacementMap) { - List subParts = constraint.getConstraintSubParts(); - for (Constraint subPart : subParts) { - if (subPart instanceof LiteralConstraint) { - String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); - if (featureReplacementMap.containsKey(toReplace)) { - LiteralConstraint newLiteral = new LiteralConstraint(featureReplacementMap.get(toReplace)); - constraint.replaceConstraintSubPart(subPart, newLiteral); + if (constraint instanceof ExpressionConstraint) { + adaptExpression(((ExpressionConstraint) constraint).getLeft(), featureReplacementMap); + adaptExpression(((ExpressionConstraint) constraint).getRight(), featureReplacementMap); + }else{ + List subParts = constraint.getConstraintSubParts(); + for (Constraint subPart : subParts) { + if (subPart instanceof LiteralConstraint) { + String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); + if (featureReplacementMap.containsKey(toReplace)) { + LiteralConstraint newLiteral = new LiteralConstraint(featureReplacementMap.get(toReplace)); + constraint.replaceConstraintSubPart(subPart, newLiteral); + } + } else { + adaptConstraint(subTreeRoot, subPart, featureReplacementMap); } - } else { - adaptConstraint(subTreeRoot, subPart, featureReplacementMap); + } + } + } + + private void adaptExpression(Expression expression, Map featureReplacementMap) { + if (expression instanceof LiteralExpression) { + LiteralExpression literalExpression = (LiteralExpression) expression; + Attribute attribute = (Attribute) literalExpression.getContent(); + if (featureReplacementMap.containsKey(attribute.getFeature().getFeatureName())) { + var newAttribute = attribute.clone(); + newAttribute.setFeature(featureReplacementMap.get(attribute.getFeature().getFeatureName())); + literalExpression.setContent(newAttribute); + } + + }else{ + for (Expression subExpression : expression.getExpressionSubParts()) { + adaptExpression(subExpression, featureReplacementMap); } } } diff --git a/src/main/java/de/vill/conversion/ConvertSMTLevel.java b/src/main/java/de/vill/conversion/ConvertSMTLevel.java index 46f4eb9..e1a9e5f 100644 --- a/src/main/java/de/vill/conversion/ConvertSMTLevel.java +++ b/src/main/java/de/vill/conversion/ConvertSMTLevel.java @@ -21,47 +21,53 @@ public Set getTargetLevelsOfConversion() { return new HashSet<>(Arrays.asList(LanguageLevel.BOOLEAN_LEVEL)); } + private Constraint getFalseConstraint(FeatureModel featureModel){ + return new NotConstraint(new LiteralConstraint(featureModel.getRootFeature())); + } + @Override public void convertFeatureModel(FeatureModel rootFeatureModel, FeatureModel featureModel) { List constraints = featureModel.getFeatureConstraints(); constraints.addAll(featureModel.getOwnConstraints()); - constraints.stream().forEach(this::replaceEquationInConstraint); + for(Constraint constraint : constraints) { + replaceEquationInConstraint(constraint, featureModel); + } List replacements = new LinkedList<>(); for (Constraint constraint : featureModel.getOwnConstraints()) { if (constraint instanceof ExpressionConstraint) { - Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) constraint); + Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) constraint, getFalseConstraint(featureModel)); replacements.add(equationReplacement); } } featureModel.getOwnConstraints().removeIf(x -> x instanceof ExpressionConstraint); featureModel.getOwnConstraints().addAll(replacements); for (Constraint constraint : featureModel.getOwnConstraints()) { - convertConstraint(constraint); + convertConstraint(constraint, featureModel); } - traverseFeatures(featureModel.getRootFeature()); + traverseFeatures(featureModel.getRootFeature(), featureModel); } - private void convertConstraint(Constraint constraint) { + private void convertConstraint(Constraint constraint, FeatureModel featureModel) { for (Constraint subConstraint : constraint.getConstraintSubParts()) { if (subConstraint instanceof ExpressionConstraint) { - Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) subConstraint); + Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) subConstraint, getFalseConstraint(featureModel)); constraint.replaceConstraintSubPart(subConstraint, equationReplacement); }else{ - convertConstraint(subConstraint); + convertConstraint(subConstraint, featureModel); } } } - private void replaceEquationInConstraint(Constraint constraint) { + private void replaceEquationInConstraint(Constraint constraint, FeatureModel featureModel) { for (Constraint subConstraint : constraint.getConstraintSubParts()) { if (subConstraint instanceof ExpressionConstraint) { - Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) subConstraint); + Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) subConstraint, getFalseConstraint(featureModel)); constraint.replaceConstraintSubPart(subConstraint, equationReplacement); } } } - private Constraint convertEquationToConstraint(ExpressionConstraint equation) { + private Constraint convertEquationToConstraint(ExpressionConstraint equation, Constraint falseConstraint) { Set featuresInEquation = getFeaturesInEquation(equation); Set> featureCombinations = getFeatureCombinations(featuresInEquation); Set disjunction = new HashSet<>(); @@ -71,7 +77,11 @@ private Constraint convertEquationToConstraint(ExpressionConstraint equation) { disjunction.add(createConjunction(configuration, new HashSet<>(featuresInEquation))); } } - return new ParenthesisConstraint(createDisjunction(disjunction)); + if (disjunction.isEmpty()) { + return falseConstraint; + }else{ + return new ParenthesisConstraint(createDisjunction(disjunction)); + } } private Set getFeaturesInEquation(ExpressionConstraint equation) { @@ -142,12 +152,12 @@ private Constraint createDisjunction(Set constraints) { return orConstraint; } - private void removeEquationFromAttributes(Feature feature) { + private void removeEquationFromAttributes(Feature feature, FeatureModel featureModel) { Attribute attributeConstraint = feature.getAttributes().get("constraint"); Attribute attributeConstraintList = feature.getAttributes().get("constraints"); if (attributeConstraint != null) { if (attributeConstraint.getValue() instanceof ExpressionConstraint) { - Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) attributeConstraint.getValue()); + Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) attributeConstraint.getValue(), getFalseConstraint(featureModel)); feature.getAttributes().put("constraint", new Attribute<>("constraint", equationReplacement, feature)); } } @@ -155,7 +165,7 @@ private void removeEquationFromAttributes(Feature feature) { List newConstraintList = new LinkedList<>(); for (Object constraint : (List) attributeConstraintList.getValue()) { if (constraint instanceof ExpressionConstraint) { - Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) constraint); + Constraint equationReplacement = convertEquationToConstraint((ExpressionConstraint) constraint, getFalseConstraint(featureModel)); newConstraintList.add(equationReplacement); } else { newConstraintList.add(constraint); @@ -165,11 +175,11 @@ private void removeEquationFromAttributes(Feature feature) { } } - private void traverseFeatures(Feature feature) { - removeEquationFromAttributes(feature); + private void traverseFeatures(Feature feature, FeatureModel featureModel) { + removeEquationFromAttributes(feature, featureModel); for (Group group : feature.getChildren()) { for (Feature subFeature : group.getFeatures()) { - traverseFeatures(subFeature); + traverseFeatures(subFeature, featureModel); } } } diff --git a/src/main/java/de/vill/main/UVLModelFactory.java b/src/main/java/de/vill/main/UVLModelFactory.java index 392e3e6..cf566b8 100644 --- a/src/main/java/de/vill/main/UVLModelFactory.java +++ b/src/main/java/de/vill/main/UVLModelFactory.java @@ -261,23 +261,12 @@ private List getActualLanguageLevelsToRemoveInOrder(FeatureModel List completeOrderedLevelsToRemove = new LinkedList<>(); while (!levelsToRemoveClone.isEmpty()) { LanguageLevel highestLevel = getMaxLanguageLevel(levelsToRemoveClone); - if (LanguageLevel.isMajorLevel(highestLevel)) { - //highestLevel is major level - int numberCorrespondingMinorLevels = highestLevel.getValue() + 1; - List correspondingMinorLevels = LanguageLevel.valueOf(numberCorrespondingMinorLevels); - if (correspondingMinorLevels != null) { - correspondingMinorLevels.retainAll(featureModel.getUsedLanguageLevelsRecursively()); - completeOrderedLevelsToRemove.addAll(correspondingMinorLevels); - } + + if (featureModel.getUsedLanguageLevelsRecursively().contains(highestLevel)) { completeOrderedLevelsToRemove.add(highestLevel); - levelsToRemoveClone.remove(highestLevel); - } else { - //highestLevel is minor level - if (featureModel.getUsedLanguageLevelsRecursively().contains(highestLevel)) { - completeOrderedLevelsToRemove.add(highestLevel); - } - levelsToRemoveClone.remove(highestLevel); } + levelsToRemoveClone.remove(highestLevel); + } //SAT-level can not be removed completeOrderedLevelsToRemove.remove(LanguageLevel.BOOLEAN_LEVEL); diff --git a/src/main/java/de/vill/model/Attribute.java b/src/main/java/de/vill/model/Attribute.java index a88bca6..080a4de 100644 --- a/src/main/java/de/vill/model/Attribute.java +++ b/src/main/java/de/vill/model/Attribute.java @@ -6,6 +6,8 @@ import de.vill.model.building.VariableReference; import de.vill.model.constraint.Constraint; +import de.vill.model.expression.AddExpression; +import de.vill.model.expression.Expression; import de.vill.util.Constants; /** @@ -20,7 +22,7 @@ public class Attribute implements VariableReference { private int line; private final String name; private final T value; - private final Feature feature; + private Feature feature; /** * The constructor of the attribute class takes an attribute name (does not contain the feature name) and a value of type T @@ -82,6 +84,10 @@ public String getType() { */ public Feature getFeature() {return feature;} + public void setFeature(Feature feature) { + this.feature = feature; + } + /** * Returns a uvl representation of the attribute as string (different for the possible types of the value) * @@ -163,4 +169,13 @@ public boolean equals(Object obj) { public String getIdentifier() { return feature.getIdentifier() + "." + name; } + + @Override + public Attribute clone(){ + return new Attribute(name, value, feature); + } + + public Attribute cloneWithFeature(Feature feature){ + return new Attribute(name, value, feature); + } } diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index 6307edb..10fce20 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -630,7 +630,9 @@ public Feature clone() { feature.setSubmodelRoot(isSubmodelRoot); feature.setRelatedImport(getRelatedImport()); feature.setFeatureType(this.getFeatureType()); - feature.getAttributes().putAll(getAttributes()); + for (Map.Entry> entry : getAttributes().entrySet()){ + feature.getAttributes().put(entry.getKey(),entry.getValue().cloneWithFeature(feature)); + } for (Group group : getChildren()) { feature.getChildren().add(group.clone()); } diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 3e2b4e2..7cf2ce5 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -271,8 +271,6 @@ public StringBuilder toOPBString(){ List constraints = getConstraints(); constraints.addAll(getFeatureConstraints()); - List additionalConstraints = new LinkedList<>(); - for(Constraint constraint : constraints){ if (constraint instanceof LiteralConstraint){ PBConstraint pbConstraint = new PBConstraint(); @@ -309,15 +307,19 @@ public StringBuilder toOPBString(){ } } - var map = transformSubFormulas(subMap, additionalConstraints); + boolean sign = !(constraint instanceof NotConstraint); + Literal literal = new Literal(1, "x_" + SubstitutionVariableIndex.getInstance().peekIndex(), sign); + + List additionalSubstitutionConstraints = new LinkedList<>(); + var map = transformSubFormulas(subMap, additionalSubstitutionConstraints); List pbcList = transformImplicationMap(map); PBConstraint pbConstraint = new PBConstraint(); pbConstraint.literalList = new LinkedList<>(); pbConstraint.k = 1; - boolean sign = !(constraint instanceof NotConstraint); - Literal literal = new Literal(1, "x_" + SubstitutionVariableIndex.getInstance().peekIndex(), sign); + pbConstraint.literalList.add(literal); pbcList.add(pbConstraint); + pbcList.addAll(additionalSubstitutionConstraints); for(PBConstraint pBConstraint : pbcList){ result.numberVariables++; pBConstraint.toOPBString(result); @@ -325,9 +327,6 @@ public StringBuilder toOPBString(){ counter++; } - for (PBConstraint pBConstraint : additionalConstraints){ - pBConstraint.toOPBString(result); - } SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); result.numberVariables += substitutionVariableIndex.peekIndex(); String header = "#variable= " + result.numberVariables + " #constraint= " + result.numberConstraints + "\n"; diff --git a/src/main/java/de/vill/model/LanguageLevel.java b/src/main/java/de/vill/model/LanguageLevel.java index 43b8d94..e9a6b3a 100644 --- a/src/main/java/de/vill/model/LanguageLevel.java +++ b/src/main/java/de/vill/model/LanguageLevel.java @@ -13,14 +13,14 @@ public enum LanguageLevel { // MAJOR LEVELS (logic: val % 2 != 0) BOOLEAN_LEVEL(1, Constants.BOOLEAN_LEVEL), ARITHMETIC_LEVEL(3, Constants.ARITHMETIC_LEVEL), - TYPE_LEVEL(5, Constants.TYPE_LEVEL), + TYPE_LEVEL(7, Constants.TYPE_LEVEL), // MINOR LEVELS (logic: val % 2 == 0) GROUP_CARDINALITY(2, "group-cardinality"), - FEATURE_CARDINALITY(4, "feature-cardinality"), + FEATURE_CARDINALITY(6, "feature-cardinality"), AGGREGATE_FUNCTION(4, "aggregate-function"), - STRING_CONSTRAINTS(6, "string-constraints"), - NUMERIC_CONSTRAINTS(6, "numeric-constraints"), + STRING_CONSTRAINTS(8, "string-constraints"), + NUMERIC_CONSTRAINTS(8, "numeric-constraints"), ; private final int value; diff --git a/src/main/java/de/vill/model/constraint/EqualEquationConstraint.java b/src/main/java/de/vill/model/constraint/EqualEquationConstraint.java index b8368cb..796c64e 100644 --- a/src/main/java/de/vill/model/constraint/EqualEquationConstraint.java +++ b/src/main/java/de/vill/model/constraint/EqualEquationConstraint.java @@ -7,25 +7,21 @@ import java.util.List; public class EqualEquationConstraint extends ExpressionConstraint { - private final Expression left; - private final Expression right; public EqualEquationConstraint(final Expression left, final Expression right) { super(left, right, "=="); - this.left = left; - this.right = right; } @Override public Constraint clone() { - return new EqualEquationConstraint(this.left, this.right); + return new EqualEquationConstraint(getLeft().clone(), getRight().clone()); } @Override public List getReferences() { List references = new ArrayList<>(); - references.addAll(left.getReferences()); - references.addAll(right.getReferences()); + references.addAll(getLeft().getReferences()); + references.addAll(getRight().getReferences()); return references; } } diff --git a/src/main/java/de/vill/model/constraint/GreaterEqualsEquationConstraint.java b/src/main/java/de/vill/model/constraint/GreaterEqualsEquationConstraint.java index 130c6fd..4aca930 100644 --- a/src/main/java/de/vill/model/constraint/GreaterEqualsEquationConstraint.java +++ b/src/main/java/de/vill/model/constraint/GreaterEqualsEquationConstraint.java @@ -8,13 +8,8 @@ import java.util.List; public class GreaterEqualsEquationConstraint extends ExpressionConstraint { - private final Expression left; - private final Expression right; - public GreaterEqualsEquationConstraint(final Expression left, final Expression right) { super(left, right, ">="); - this.left = left; - this.right = right; } @Override @@ -24,14 +19,14 @@ public List getConstraintSubParts() { @Override public Constraint clone() { - return new GreaterEqualsEquationConstraint(this.left, this.right); + return new GreaterEqualsEquationConstraint(getLeft().clone(), getRight().clone()); } @Override public List getReferences() { List references = new ArrayList<>(); - references.addAll(left.getReferences()); - references.addAll(right.getReferences()); + references.addAll(getLeft().getReferences()); + references.addAll(getRight().getReferences()); return references; } } diff --git a/src/main/java/de/vill/model/constraint/GreaterEquationConstraint.java b/src/main/java/de/vill/model/constraint/GreaterEquationConstraint.java index 6074f44..e323cd8 100644 --- a/src/main/java/de/vill/model/constraint/GreaterEquationConstraint.java +++ b/src/main/java/de/vill/model/constraint/GreaterEquationConstraint.java @@ -8,13 +8,8 @@ import java.util.List; public class GreaterEquationConstraint extends ExpressionConstraint { - private final Expression left; - private final Expression right; - public GreaterEquationConstraint(final Expression left, final Expression right) { super(left, right, ">"); - this.left = left; - this.right = right; } @Override @@ -24,14 +19,14 @@ public List getConstraintSubParts() { @Override public Constraint clone() { - return new GreaterEquationConstraint(this.left, this.right); + return new GreaterEquationConstraint(getLeft().clone(), getRight().clone()); } @Override public List getReferences() { List references = new ArrayList<>(); - references.addAll(left.getReferences()); - references.addAll(right.getReferences()); + references.addAll(getLeft().getReferences()); + references.addAll(getRight().getReferences()); return references; } } diff --git a/src/main/java/de/vill/model/constraint/LowerEqualsEquationConstraint.java b/src/main/java/de/vill/model/constraint/LowerEqualsEquationConstraint.java index a0e0dc4..ab03bcb 100644 --- a/src/main/java/de/vill/model/constraint/LowerEqualsEquationConstraint.java +++ b/src/main/java/de/vill/model/constraint/LowerEqualsEquationConstraint.java @@ -5,13 +5,8 @@ import java.util.List; public class LowerEqualsEquationConstraint extends ExpressionConstraint { - private final Expression left; - private final Expression right; - public LowerEqualsEquationConstraint(final Expression left, final Expression right) { super(left, right, "<="); - this.left = left; - this.right = right; } @Override @@ -21,6 +16,6 @@ public List getConstraintSubParts() { @Override public Constraint clone() { - return new LowerEqualsEquationConstraint(this.left, this.right); + return new LowerEqualsEquationConstraint(getLeft().clone(), getRight().clone()); } } diff --git a/src/main/java/de/vill/model/constraint/LowerEquationConstraint.java b/src/main/java/de/vill/model/constraint/LowerEquationConstraint.java index bec7314..4f6f991 100644 --- a/src/main/java/de/vill/model/constraint/LowerEquationConstraint.java +++ b/src/main/java/de/vill/model/constraint/LowerEquationConstraint.java @@ -5,13 +5,8 @@ import java.util.List; public class LowerEquationConstraint extends ExpressionConstraint { - private final Expression left; - private final Expression right; - public LowerEquationConstraint(final Expression left, final Expression right) { super(left, right, "<"); - this.left = left; - this.right = right; } @Override @@ -21,6 +16,6 @@ public List getConstraintSubParts() { @Override public Constraint clone() { - return new LowerEquationConstraint(this.left, this.right); + return new LowerEquationConstraint(getLeft().clone(), getRight().clone()); } } diff --git a/src/main/java/de/vill/model/constraint/NotEqualsEquationConstraint.java b/src/main/java/de/vill/model/constraint/NotEqualsEquationConstraint.java index 852d1d4..35470f4 100644 --- a/src/main/java/de/vill/model/constraint/NotEqualsEquationConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotEqualsEquationConstraint.java @@ -5,13 +5,8 @@ import java.util.List; public class NotEqualsEquationConstraint extends ExpressionConstraint { - private final Expression left; - private final Expression right; - public NotEqualsEquationConstraint(final Expression left, final Expression right) { super(left, right, "!="); - this.left = left; - this.right = right; } @Override @@ -21,6 +16,6 @@ public List getConstraintSubParts() { @Override public Constraint clone() { - return new NotEqualsEquationConstraint(this.left, this.right); + return new NotEqualsEquationConstraint(getLeft().clone(), getRight().clone()); } } diff --git a/src/main/java/de/vill/model/expression/AddExpression.java b/src/main/java/de/vill/model/expression/AddExpression.java index b0ec73c..3c45d56 100644 --- a/src/main/java/de/vill/model/expression/AddExpression.java +++ b/src/main/java/de/vill/model/expression/AddExpression.java @@ -87,11 +87,17 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalSubstitution) { List result = new LinkedList<>(); - result.addAll(left.getAsSum(additionalConstraints)); - List rightSum = right.getAsSum(additionalConstraints); + result.addAll(left.getAsSum(additionalSubstitution)); + List rightSum = right.getAsSum(additionalSubstitution); result.addAll(rightSum); return result; } + + @Override + public Expression clone(){ + return new AddExpression(left.clone(), right.clone()); + } + } diff --git a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java index 3833994..2747508 100644 --- a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java @@ -8,10 +8,8 @@ import de.vill.model.pbc.Literal; import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; -import java.util.Set; + +import java.util.*; public class AggregateFunctionExpression extends Expression { @@ -117,7 +115,12 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalSubstitution) { throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); } + + @Override + public Expression clone(){ + return new AggregateFunctionExpression(attribute, rootFeature); + } } diff --git a/src/main/java/de/vill/model/expression/DivExpression.java b/src/main/java/de/vill/model/expression/DivExpression.java index 6d90934..ef7ea9b 100644 --- a/src/main/java/de/vill/model/expression/DivExpression.java +++ b/src/main/java/de/vill/model/expression/DivExpression.java @@ -91,10 +91,10 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalSubstitution) { List result = new LinkedList<>(); - List numeratorSum = getLeft().getAsSum(additionalConstraints); - List denominatorSum = getRight().getAsSum(additionalConstraints); + List numeratorSum = getLeft().getAsSum(additionalSubstitution); + List denominatorSum = getRight().getAsSum(additionalSubstitution); SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); for (Literal l : numeratorSum) { Set> literalCombinations = getLiteralCombinations(new HashSet(denominatorSum)); @@ -106,13 +106,16 @@ public List getAsSum(List additionalConstraints) { denominatorFactorSum += denominatorLiteral.factor; } newSummand.factor /= denominatorFactorSum; - newSummand.name = substitutionVariableIndex.getSubName(); + var subIndex = substitutionVariableIndex.getIndex(); + newSummand.name = "x_" + subIndex; result.add(newSummand); PBConstraint denominatorConstraint = featureCombinationToPBConstraint(combination, denominatorSum); - denominatorConstraint.literalList.add(new Literal(1, l.name, true)); - denominatorConstraint.k += 1; - additionalConstraints.addAll(substitutionConstraint(denominatorConstraint, newSummand.name)); - //TODO add x <=> l & combination (with positive and negative literals) + if (l.name != null) { + denominatorConstraint.literalList.add(new Literal(1, l.name, l.sign)); + denominatorConstraint.k += 1; + } + + additionalSubstitution.addAll(substitutionConstraint(denominatorConstraint, newSummand.name)); } } return result; @@ -131,22 +134,29 @@ private PBConstraint featureCombinationToPBConstraint(Set takenLiterals pbConstraint.literalList = new LinkedList<>(); pbConstraint.k = allLiterals.size(); for (Literal literal : allLiterals) { - if (takenLiterals.contains(literal)) { - //literal positive in result - Literal newLiteral = new Literal(); - newLiteral.name = literal.name; - newLiteral.factor = 1; - pbConstraint.literalList.add(newLiteral); - }else { - //literal negative in result - Literal negatedLiteral = new Literal(); - negatedLiteral.name = literal.name; - negatedLiteral.factor = -1; - pbConstraint.k -= 1; - pbConstraint.literalList.add(negatedLiteral); + if (literal.name != null){ + if (takenLiterals.contains(literal)) { + //literal positive in result + Literal newLiteral = new Literal(); + newLiteral.name = literal.name; + newLiteral.factor = 1; + newLiteral.sign = literal.sign; + pbConstraint.literalList.add(newLiteral); + }else { + //literal negative in result + Literal negatedLiteral = new Literal(); + negatedLiteral.name = literal.name; + negatedLiteral.factor = 1; + negatedLiteral.sign = !literal.sign; + pbConstraint.literalList.add(negatedLiteral); + } } - } return pbConstraint; } + + @Override + public Expression clone(){ + return new DivExpression(left.clone(), right.clone()); + } } diff --git a/src/main/java/de/vill/model/expression/Expression.java b/src/main/java/de/vill/model/expression/Expression.java index 7d2719f..d2d6a2d 100644 --- a/src/main/java/de/vill/model/expression/Expression.java +++ b/src/main/java/de/vill/model/expression/Expression.java @@ -2,10 +2,12 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; +import de.vill.model.constraint.Constraint; import de.vill.model.pbc.Literal; import de.vill.model.pbc.PBConstraint; import java.util.List; +import java.util.Map; import java.util.Set; public abstract class Expression { @@ -44,7 +46,10 @@ public int hashCode() { @Override public abstract boolean equals(Object obj); + @Override + public abstract Expression clone(); + public abstract List getReferences(); - public abstract List getAsSum(List additionalConstraints); + public abstract List getAsSum(List additionalSubstitution); } diff --git a/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java index c9a31f0..7d7debc 100644 --- a/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java @@ -90,7 +90,12 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalSubstitution) { throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); } + + @Override + public Expression clone(){ + return new LengthAggregateFunctionExpression(getReference()); + } } diff --git a/src/main/java/de/vill/model/expression/LiteralExpression.java b/src/main/java/de/vill/model/expression/LiteralExpression.java index 79e1553..7f2ce56 100644 --- a/src/main/java/de/vill/model/expression/LiteralExpression.java +++ b/src/main/java/de/vill/model/expression/LiteralExpression.java @@ -125,7 +125,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalSubstitution) { Literal l = new Literal(); var attribute = (Attribute)getContent(); l.name = attribute.getFeature().getFeatureName(); @@ -135,4 +135,9 @@ public List getAsSum(List additionalConstraints) { return result; } + @Override + public Expression clone(){ + return new LiteralExpression(content); + } + } diff --git a/src/main/java/de/vill/model/expression/MulExpression.java b/src/main/java/de/vill/model/expression/MulExpression.java index 8a785dc..6953228 100644 --- a/src/main/java/de/vill/model/expression/MulExpression.java +++ b/src/main/java/de/vill/model/expression/MulExpression.java @@ -97,9 +97,9 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { - var leftSum = left.getAsSum(additionalConstraints); - var rightSum = right.getAsSum(additionalConstraints); + public List getAsSum(List additionalSubstitution) { + var leftSum = left.getAsSum(additionalSubstitution); + var rightSum = right.getAsSum(additionalSubstitution); List result = new LinkedList<>(); SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); for (int i=0;i getAsSum(List additionalConstraints) { }else { Literal l = new Literal(); l.factor = leftSum.get(i).factor * rightSum.get(j).factor; - l.name = substitutionVariableIndex.getSubName(); + var subIndex = substitutionVariableIndex.getIndex(); + l.name = "x_" + subIndex; result.add(l); - additionalConstraints.addAll(getSubstitutionConstraints(leftSum.get(i).name, rightSum.get(j).name, l.name)); + additionalSubstitution.addAll(getSubstitutionConstraints(leftSum.get(i).name, rightSum.get(j).name, l.name)); } } } @@ -145,4 +146,9 @@ private List getSubstitutionConstraints(String a, String b, String public String getReturnType() { return Constants.NUMBER; } + + @Override + public Expression clone(){ + return new MulExpression(left.clone(), right.clone()); + } } diff --git a/src/main/java/de/vill/model/expression/NumberExpression.java b/src/main/java/de/vill/model/expression/NumberExpression.java index 0e5d3ef..8be8158 100644 --- a/src/main/java/de/vill/model/expression/NumberExpression.java +++ b/src/main/java/de/vill/model/expression/NumberExpression.java @@ -85,7 +85,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalSubstitution) { List result = new LinkedList<>(); result.add(new Literal(number, null, true)); return result; @@ -95,4 +95,9 @@ public List getAsSum(List additionalConstraints) { public String getReturnType() { return Constants.NUMBER; } + + @Override + public Expression clone(){ + return new NumberExpression(getNumber()); + } } diff --git a/src/main/java/de/vill/model/expression/ParenthesisExpression.java b/src/main/java/de/vill/model/expression/ParenthesisExpression.java index 7e02a2d..ef89972 100644 --- a/src/main/java/de/vill/model/expression/ParenthesisExpression.java +++ b/src/main/java/de/vill/model/expression/ParenthesisExpression.java @@ -76,12 +76,17 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { - return getContent().getAsSum(additionalConstraints); + public List getAsSum(List additionalSubstitution) { + return getContent().getAsSum(additionalSubstitution); } @Override public String getReturnType() { return content.getReturnType(); } + + @Override + public Expression clone(){ + return new ParenthesisExpression(content.clone()); + } } diff --git a/src/main/java/de/vill/model/expression/StringExpression.java b/src/main/java/de/vill/model/expression/StringExpression.java index 6ffbb27..332cc16 100644 --- a/src/main/java/de/vill/model/expression/StringExpression.java +++ b/src/main/java/de/vill/model/expression/StringExpression.java @@ -82,7 +82,7 @@ public List getReferences() { } @Override - public List getAsSum(List additionalConstraints) { + public List getAsSum(List additionalSubstitution) { throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); } @@ -90,4 +90,9 @@ public List getAsSum(List additionalConstraints) { public String getReturnType() { return Constants.STRING; } + + @Override + public Expression clone(){ + return new StringExpression(getString()); + } } diff --git a/src/main/java/de/vill/model/expression/SubExpression.java b/src/main/java/de/vill/model/expression/SubExpression.java index 4af3b94..9c7773d 100644 --- a/src/main/java/de/vill/model/expression/SubExpression.java +++ b/src/main/java/de/vill/model/expression/SubExpression.java @@ -78,9 +78,9 @@ public List getReferences() { return result; } - public List getAsSum(List additionalConstraints) { - var result = left.getAsSum(additionalConstraints); - var rightResult = right.getAsSum(additionalConstraints); + public List getAsSum(List additionalSubstitution) { + var result = left.getAsSum(additionalSubstitution); + var rightResult = right.getAsSum(additionalSubstitution); for (Literal l : rightResult){ l.factor *= -1; } @@ -92,4 +92,9 @@ public List getAsSum(List additionalConstraints) { public String getReturnType() { return Constants.NUMBER; } + + @Override + public Expression clone(){ + return new SubExpression(left.clone(), right.clone()); + } } diff --git a/src/main/java/de/vill/model/pbc/Literal.java b/src/main/java/de/vill/model/pbc/Literal.java index 5364d55..ba5e94f 100644 --- a/src/main/java/de/vill/model/pbc/Literal.java +++ b/src/main/java/de/vill/model/pbc/Literal.java @@ -24,4 +24,13 @@ public Literal clone() { } return literal; } + + @Override + public String toString() { + String signString = "+"; + if (factor < 0) { + signString = ""; + } + return " " + signString + factor + " * " + (sign ? name : "neg(" + name + ")"); + } } diff --git a/src/main/java/de/vill/model/pbc/PBConstraint.java b/src/main/java/de/vill/model/pbc/PBConstraint.java index 13cf389..226846d 100644 --- a/src/main/java/de/vill/model/pbc/PBConstraint.java +++ b/src/main/java/de/vill/model/pbc/PBConstraint.java @@ -1,5 +1,6 @@ package de.vill.model.pbc; +import java.text.DecimalFormat; import java.util.LinkedList; import java.util.List; @@ -93,13 +94,16 @@ public List orWithLiteral(String literalName, boolean sign) { } public void toOPBString(OPBResult result) { + DecimalFormat df = new DecimalFormat("#.####"); for (Literal l : literalList) { if (!l.sign){ k -= l.factor; l.factor *= -1; l.sign = !l.sign; } + l.factor = Double.parseDouble(df.format(l.factor)); } + k = Double.parseDouble(df.format(k)); result.numberConstraints++; int maxDecimalPlaces = getMaxDecimalPlaces(); for(Literal l : literalList){ @@ -162,5 +166,15 @@ public PBConstraint clone() { return pbConstraint; } + + @Override + public String toString() { + String result = ""; + for (Literal literal : literalList) { + result += literal.toString(); + } + result += " " + type + k; + return result; + } } diff --git a/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java b/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java index d30d932..55beabc 100644 --- a/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java +++ b/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java @@ -3,6 +3,8 @@ import de.vill.conversion.IConversionStrategy; import de.vill.model.*; import de.vill.model.constraint.*; +import de.vill.model.expression.Expression; +import de.vill.model.expression.LiteralExpression; import javax.smartcardio.Card; import java.util.*; @@ -36,29 +38,34 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel int min = feature.getCardinality().lower; int max = feature.getCardinality().upper; Group newChildren = new Group(Group.GroupType.GROUP_CARDINALITY); - newChildren.setCardinality(new Cardinality(min, max)); + newChildren.setCardinality(new Cardinality(min == 0 ? min + 1 : min, min == 0 ? max + 1 : max)); feature.setCardinality(null); - for (int i = Math.max(min,1); i <= max; i++) { + for (int i = min; i <= max; i++) { Feature subTreeClone = feature.clone(); - addPrefixToNamesRecursively(subTreeClone, "_" + i); + addPrefixToNamesRecursively(subTreeClone, "_" + i, featureModel); newChildren.getFeatures().add(subTreeClone); subTreeClone.setParentGroup(newChildren); - Map constraintReplacementMap = new HashMap<>(); - createFeatureReplacementMap(feature, subTreeClone, constraintReplacementMap); - constraintReplacementMap.remove(feature.getFeatureName()); - for (Constraint constraint : constraintsToClone) { - Constraint newConstraint = constraint.clone(); - adaptConstraint(subTreeClone, newConstraint, constraintReplacementMap); - LiteralConstraint subTreeRootConstraint = new LiteralConstraint(subTreeClone); - newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newConstraint)); - featureModel.getOwnConstraints().add(newConstraint); + if (i == 0) { + subTreeClone.getChildren().clear(); + }else{ + Map constraintReplacementMap = new HashMap<>(); + createFeatureReplacementMap(feature, subTreeClone, constraintReplacementMap); + constraintReplacementMap.remove(feature.getFeatureName()); + for (Constraint constraint : constraintsToClone) { + Constraint newConstraint = constraint.clone(); + adaptConstraint(subTreeClone, newConstraint, constraintReplacementMap); + LiteralConstraint subTreeRootConstraint = new LiteralConstraint(subTreeClone); + newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newConstraint)); + featureModel.getOwnConstraints().add(newConstraint); + } } + } - for (int i = Math.max(min,1); i < max; i++) { + for (int i = min; i < max; i++) { Constraint lastTakenInGroupCardinality = new LiteralConstraint(newChildren.getFeatures().get(i - min)); List notToTakeInGroupCarrdinality = new LinkedList<>(); for (int k=i+1;k<=max;k++){ @@ -67,11 +74,51 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel Constraint groupCardinalityOrderConstraint = new ImplicationConstraint(new NotConstraint(lastTakenInGroupCardinality), new NotConstraint(createDisjunction(notToTakeInGroupCarrdinality))); featureModel.getOwnConstraints().add(groupCardinalityOrderConstraint); } + + /* + new constraint with all cloned features ored + Set allFeatureNamesInSubTree = new HashSet<>(); + getAllSubFeatureNamesRecursively(feature, allFeatureNamesInSubTree); + for (Constraint constraint : constraintsToClone) { + Constraint newConstraint = constraint.clone(); + orAdaptedConstraint(newConstraint, allFeatureNamesInSubTree, min, max, featureModel); + featureModel.getOwnConstraints().add(newConstraint); + } + + */ + feature.getChildren().removeAll(feature.getChildren()); feature.getChildren().add(newChildren); newChildren.setParentFeature(feature); } + private void orAdaptedConstraint(Constraint constraint, Set featuresToReplace, int min, int max, FeatureModel featureModel) { + for (Constraint subPart : constraint.getConstraintSubParts()) { + if (subPart instanceof LiteralConstraint) { + String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); + if (featuresToReplace.contains(toReplace)){ + Feature f = featureModel.getFeatureMap().get(toReplace + "_" + min); + Constraint newOr = new LiteralConstraint(f); + for (int i = min + 1; i <= max; i++) { + newOr = new OrConstraint(newOr, new LiteralConstraint(featureModel.getFeatureMap().get(toReplace + "_" + i))); + } + constraint.replaceConstraintSubPart(subPart, new ParenthesisConstraint(newOr)); + } + }else { + orAdaptedConstraint(subPart, featuresToReplace, min, max, featureModel); + } + } + } + + private void getAllSubFeatureNamesRecursively(Feature feature, Set names) { + names.add(feature.getFeatureName()); + for (Group child : feature.getChildren()) { + for(Feature childFeature : child.getFeatures()){ + getAllSubFeatureNamesRecursively(childFeature, names); + } + } + } + private Constraint createDisjunction(List literals) { if (literals.size() == 1) { return literals.get(0); @@ -81,12 +128,13 @@ private Constraint createDisjunction(List literals) { return new OrConstraint(literalConstraint, createDisjunction(literals)); } - private void addPrefixToNamesRecursively(Feature feature, String prefix) { + private void addPrefixToNamesRecursively(Feature feature, String prefix, FeatureModel featureModel) { feature.setFeatureName(feature.getFeatureName() + prefix); + featureModel.getFeatureMap().put(feature.getFeatureName(), feature); if (!feature.isSubmodelRoot()) { for (Group group : feature.getChildren()) { for (Feature subFeature : group.getFeatures()) { - addPrefixToNamesRecursively(subFeature, prefix); + addPrefixToNamesRecursively(subFeature, prefix, featureModel); } } } @@ -117,6 +165,17 @@ private List getFeatureFromSubTree(Group group) { } private boolean constraintContains(Constraint constraint, List subTreeFeatures) { + if (constraint instanceof LiteralConstraint && ((LiteralConstraint) constraint).getReference() instanceof Feature) { + Feature feature = (Feature) ((LiteralConstraint) constraint).getReference(); + if (subTreeFeatures.contains(feature)) { + return true; + } + }else if (constraint instanceof ExpressionConstraint) { + Expression left = ((ExpressionConstraint) constraint).getLeft(); + Expression right = ((ExpressionConstraint) constraint).getRight(); + return expressionContains(left,subTreeFeatures) || expressionContains(right,subTreeFeatures); + } + List subParts = constraint.getConstraintSubParts(); for (Constraint subPart : subParts) { if (subPart instanceof LiteralConstraint && ((LiteralConstraint) subPart).getReference() instanceof Feature) { @@ -134,6 +193,27 @@ private boolean constraintContains(Constraint constraint, List subTreeF return false; } + private boolean expressionContains(Expression expression, List subTreeFeatures) { + if (expression instanceof LiteralExpression) { + Feature feature = (Feature) ((Attribute) ((LiteralExpression) expression).getContent()).getFeature(); + if (subTreeFeatures.contains(feature)) { + return true; + } + } + + for (Expression subExpression : expression.getExpressionSubParts()) { + if (expression instanceof LiteralExpression) { + Feature feature = (Feature) ((LiteralExpression) expression).getContent(); + if (subTreeFeatures.contains(feature)) { + return true; + } + }else if(expressionContains(subExpression, subTreeFeatures)){ + return true; + } + } + return false; + } + private void createFeatureReplacementMap(Feature oldSubTree, Feature newSubTree, Map featureFeatureMap) { featureFeatureMap.put(oldSubTree.getFeatureName(), newSubTree); @@ -147,17 +227,39 @@ private void createFeatureReplacementMap(Feature oldSubTree, Feature newSubTree, } private void adaptConstraint(Feature subTreeRoot, Constraint constraint, Map featureReplacementMap) { - List subParts = constraint.getConstraintSubParts(); - for (Constraint subPart : subParts) { - if (subPart instanceof LiteralConstraint) { - String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); - if (featureReplacementMap.containsKey(toReplace)) { - LiteralConstraint subTreeRootConstraint = new LiteralConstraint(subTreeRoot); - LiteralConstraint newLiteral = new LiteralConstraint(featureReplacementMap.get(toReplace)); - constraint.replaceConstraintSubPart(subPart, newLiteral); + if (constraint instanceof ExpressionConstraint) { + adaptExpression(((ExpressionConstraint) constraint).getLeft(), featureReplacementMap); + adaptExpression(((ExpressionConstraint) constraint).getRight(), featureReplacementMap); + }else{ + List subParts = constraint.getConstraintSubParts(); + for (Constraint subPart : subParts) { + if (subPart instanceof LiteralConstraint) { + String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); + if (featureReplacementMap.containsKey(toReplace)) { + LiteralConstraint subTreeRootConstraint = new LiteralConstraint(subTreeRoot); + LiteralConstraint newLiteral = new LiteralConstraint(featureReplacementMap.get(toReplace)); + constraint.replaceConstraintSubPart(subPart, newLiteral); + } + } else { + adaptConstraint(subTreeRoot, subPart, featureReplacementMap); } - } else { - adaptConstraint(subTreeRoot, subPart, featureReplacementMap); + } + } + } + + private void adaptExpression(Expression expression, Map featureReplacementMap) { + if (expression instanceof LiteralExpression) { + LiteralExpression literalExpression = (LiteralExpression) expression; + Attribute attribute = (Attribute) literalExpression.getContent(); + if (featureReplacementMap.containsKey(attribute.getFeature().getFeatureName())) { + var newAttribute = attribute.clone(); + newAttribute.setFeature(featureReplacementMap.get(attribute.getFeature().getFeatureName())); + literalExpression.setContent(newAttribute); + } + + }else{ + for (Expression subExpression : expression.getExpressionSubParts()) { + adaptExpression(subExpression, featureReplacementMap); } } } diff --git a/src/main/java/de/vill/util/SubstitutionVariableIndex.java b/src/main/java/de/vill/util/SubstitutionVariableIndex.java index 62b410d..4fbedfa 100644 --- a/src/main/java/de/vill/util/SubstitutionVariableIndex.java +++ b/src/main/java/de/vill/util/SubstitutionVariableIndex.java @@ -16,7 +16,7 @@ public static SubstitutionVariableIndex getInstance() { public String getSubName() { index++; - return "sub_z_" + index; + return "x_" + index; } public int getIndex() { diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 2be144a..b7d9c69 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -110,17 +110,34 @@ public static boolean isJustOr(Constraint constraint){ public static List transformImplicationMap (HashMap> implicationMap){ List resultList = new LinkedList<>(); + SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); for (Map.Entry> entry : implicationMap.entrySet()) { int index = entry.getKey(); - for(PBConstraint constraint : entry.getValue()){ - resultList.addAll(substitutionConstraint(constraint, "x_" + index)); + if (entry.getValue().size() > 1) { + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.k = entry.getValue().size(); + + for(PBConstraint constraint : entry.getValue()){ + String subName = substitutionVariableIndex.getSubName(); + pbConstraint.literalList.add(new Literal( + 1, subName, true + )); + resultList.addAll(substitutionConstraint(constraint, subName)); + } + resultList.addAll(substitutionConstraint(pbConstraint, "x_" + index)); + }else { + for(PBConstraint constraint : entry.getValue()){ + resultList.addAll(substitutionConstraint(constraint, "x_" + index)); + } } + } return resultList; } public static List substitutionConstraint(PBConstraint constraint, String substitutionName) { + System.out.println(substitutionName + " <=> " + constraint.toString()); List resultList = new LinkedList<>(); // x <=> constraint is the same as -x v constraint AND x v -constraint // -x v constraint @@ -130,15 +147,15 @@ public static List substitutionConstraint(PBConstraint constraint, return resultList; } - public static HashMap> transformSubFormulas(HashMap subformulas, List additionalConstraints){ + public static HashMap> transformSubFormulas(HashMap subformulas, List additionalSubstitution){ HashMap> resultMap = new HashMap<>(); for (Map.Entry entry : subformulas.entrySet()) { - resultMap.put(entry.getKey(), transformSubFormula(entry.getValue(), additionalConstraints)); + resultMap.put(entry.getKey(), transformSubFormula(entry.getValue(), additionalSubstitution)); } return resultMap; } - public static List transformSubFormula(Constraint constraint, List additionalConstraints){ + public static List transformSubFormula(Constraint constraint, List additionalSubstitution){ List resultList = new LinkedList<>(); if(constraint instanceof NotConstraint){ System.err.println("error"); @@ -158,9 +175,8 @@ else if (constraint instanceof OrConstraint) { } else if (constraint instanceof ExpressionConstraint) { ExpressionConstraint expressionConstraint = (ExpressionConstraint) constraint; - resultList.add(transformExpression(expressionConstraint, additionalConstraints)); - } - return resultList; + resultList.addAll(transformExpression(expressionConstraint, additionalSubstitution)); + }return resultList; } public static PBConstraint transformNegLiteral(NotConstraint constraint){ @@ -271,15 +287,16 @@ public static PBConstraint transformOr(Constraint constraint){ } } - public static PBConstraint transformExpression(ExpressionConstraint constraint, List additionalConstraints) { + public static List transformExpression(ExpressionConstraint constraint, List additionalSubstitution) { + List additionalConstraints = new LinkedList<>(); List allDenominators = new LinkedList<>(); collectDenominators(constraint.getLeft(), allDenominators); collectDenominators(constraint.getRight(), allDenominators); additionalConstraints.addAll(getConstraintsToForbidZeroDivision(allDenominators)); //transform everything to a sum - var leftSum = constraint.getLeft().getAsSum(additionalConstraints); - var rightSum = constraint.getRight().getAsSum(additionalConstraints); + var leftSum = constraint.getLeft().getAsSum(additionalSubstitution); + var rightSum = constraint.getRight().getAsSum(additionalSubstitution); //take all numbers to the right side List numbersFromLeftToRight = leftSum.stream().filter(x -> x.name == null).collect(Collectors.toList()); for (Literal l : numbersFromLeftToRight){ @@ -326,7 +343,9 @@ public static PBConstraint transformExpression(ExpressionConstraint constraint, pbConstraint.literalList.add(new Literal(e.getValue(), e.getKey(), true)); } - return pbConstraint; + additionalConstraints.add(pbConstraint); + + return additionalConstraints; } public static void collectDenominators(Expression expression, List denominators) { From 89d16450924edda107ba47aea8403f375072755e Mon Sep 17 00:00:00 2001 From: Stefan Date: Sat, 30 Nov 2024 10:47:42 +0100 Subject: [PATCH 45/60] feat: added support for distributive cross-tree constraint encoding (vs tseitin style cross-tree constraint encoding) --- pom.xml | 17 +- src/main/java/de/vill/model/FeatureModel.java | 56 +--- .../vill/model/constraint/NotConstraint.java | 2 - src/main/java/de/vill/util/Util.java | 265 +++++++++++++++++- 4 files changed, 278 insertions(+), 62 deletions(-) diff --git a/pom.xml b/pom.xml index eb4aa0f..e80c7b4 100644 --- a/pom.xml +++ b/pom.xml @@ -87,6 +87,21 @@ guava 31.0.1-jre + + uvl + uvl + 1.0.0 + + + de.ovgu.featureide + featureide + 1.0.0 + + + org.antlr + antlr + 3.4.0 + @@ -101,7 +116,7 @@ - fully.qualified.MainClass + de.vill.main.Eval diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 7cf2ce5..493528f 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -266,65 +266,13 @@ public StringBuilder toOPBString(){ result.opbString.append(" >= 1;\n"); result.numberConstraints++; getRootFeature().toOPBString(result); - int counter = 0; List constraints = getConstraints(); constraints.addAll(getFeatureConstraints()); for(Constraint constraint : constraints){ - if (constraint instanceof LiteralConstraint){ - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = 1; - Literal literal = new Literal(1, ((LiteralConstraint) constraint).getReference().getIdentifier(), true); - pbConstraint.literalList.add(literal); - result.numberVariables++; - pbConstraint.toOPBString(result); - continue; - } - HashMap subMap = new HashMap<>(); - constraint.extractTseitinSubConstraints(subMap); - - if (subMap.isEmpty()) { - if (constraint instanceof LiteralConstraint){ - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = 1; - Literal literal = new Literal(1, ((LiteralConstraint) constraint).getReference().getIdentifier(), true); - pbConstraint.literalList.add(literal); - result.numberVariables++; - pbConstraint.toOPBString(result); - continue; - }else if(constraint instanceof NotConstraint){ - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = 0; - Literal literal = new Literal(-1, ((LiteralConstraint)((NotConstraint)constraint).getContent()).getReference().getIdentifier(), true); - pbConstraint.literalList.add(literal); - result.numberVariables++; - pbConstraint.toOPBString(result); - continue; - } - } - - boolean sign = !(constraint instanceof NotConstraint); - Literal literal = new Literal(1, "x_" + SubstitutionVariableIndex.getInstance().peekIndex(), sign); - - List additionalSubstitutionConstraints = new LinkedList<>(); - var map = transformSubFormulas(subMap, additionalSubstitutionConstraints); - List pbcList = transformImplicationMap(map); - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = 1; - - pbConstraint.literalList.add(literal); - pbcList.add(pbConstraint); - pbcList.addAll(additionalSubstitutionConstraints); - for(PBConstraint pBConstraint : pbcList){ - result.numberVariables++; - pBConstraint.toOPBString(result); - } - counter++; + constraintDistributiveToOPB(constraint,result); + //encodeConstraintTseitinStyle(constraint, result); } SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index 2f16cdf..70f2c77 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -2,8 +2,6 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.PBCLiteralConstraint; -import de.vill.util.SubstitutionVariableIndex; -import org.prop4j.Or; import java.util.*; diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index b7d9c69..d14b048 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -1,12 +1,10 @@ package de.vill.util; import de.vill.config.Configuration; +import de.vill.model.building.VariableReference; import de.vill.model.constraint.*; import de.vill.model.expression.*; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCLiteralConstraint; -import de.vill.model.pbc.PBConstraint; -import de.vill.model.pbc.PBConstraintType; +import de.vill.model.pbc.*; import java.io.IOException; import java.nio.file.Files; @@ -137,7 +135,7 @@ public static List transformImplicationMap (HashMap substitutionConstraint(PBConstraint constraint, String substitutionName) { - System.out.println(substitutionName + " <=> " + constraint.toString()); + //System.out.println(substitutionName + " <=> " + constraint.toString()); List resultList = new LinkedList<>(); // x <=> constraint is the same as -x v constraint AND x v -constraint // -x v constraint @@ -387,4 +385,261 @@ public static List getConstraintsToForbidZeroDivision(List= "); + stringBuilder.append(1 - negatives); + stringBuilder.append(";\n"); + }else { + var and = (AndConstraint) constraint; + if (and.getLeft() instanceof AndConstraint){ + cnfToOpb(and.getLeft(), stringBuilder); + }else{ + int negatives = clauseToOpb(and.getLeft(), stringBuilder); + stringBuilder.append(" >= "); + stringBuilder.append(1 - negatives); + stringBuilder.append(";\n"); + } + + if (and.getRight() instanceof AndConstraint){ + cnfToOpb(and.getRight(), stringBuilder); + }else{ + int negatives = clauseToOpb(and.getRight(), stringBuilder); + stringBuilder.append(" >= "); + stringBuilder.append(1 - negatives); + stringBuilder.append(";\n"); + } + } + } + + private static int clauseToOpb(Constraint constraint, StringBuilder stringBuilder) { + int negatives = 0; + if (constraint instanceof NotConstraint) { + stringBuilder.append(" -1 * "); + var literal = (LiteralConstraint)((NotConstraint) constraint).getContent(); + stringBuilder.append('"'); + stringBuilder.append(literal.getReference().getIdentifier()); + stringBuilder.append('"'); + negatives++; + }else if (constraint instanceof LiteralConstraint){ + stringBuilder.append(" +1 * "); + var literal = (LiteralConstraint)constraint; + stringBuilder.append('"'); + stringBuilder.append(literal.getReference().getIdentifier()); + stringBuilder.append('"'); + }else { + var or = (OrConstraint)constraint; + negatives += clauseToOpb(or.getLeft(), stringBuilder); + negatives += clauseToOpb(or.getRight(), stringBuilder); + } + return negatives; + } + + private static Constraint removeParenthesisConstraint(Constraint constraint){ + if (constraint instanceof ParenthesisConstraint){ + return removeParenthesisConstraint(((ParenthesisConstraint) constraint).getContent()); + }else{ + for (Constraint subConstraint : constraint.getConstraintSubParts()){ + constraint.replaceConstraintSubPart(subConstraint, removeParenthesisConstraint(subConstraint)); + } + } + return constraint; + } + + private static Constraint substituteExpressions(Constraint constraint, OPBResult result){ + if (constraint instanceof ExpressionConstraint){ + SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); + int subIndex = substitutionVariableIndex.getIndex(); + String subName = "x_" + subIndex; + LiteralConstraint subLiteral = new LiteralConstraint(new VariableReference() { + @Override + public String getIdentifier() { + return subName; + } + }); + HashMap> subMap = new HashMap<>(); + List additionalSubs = new LinkedList<>(); + List expressionEncoding = transformExpression((ExpressionConstraint) constraint, additionalSubs); + subMap.put(subIndex, expressionEncoding); + List resultList = transformImplicationMap(subMap); + resultList.addAll(additionalSubs); + for (PBConstraint pbConstraint : resultList){ + pbConstraint.toOPBString(result); + } + return subLiteral; + }else{ + for (Constraint subConstraint : constraint.getConstraintSubParts()){ + constraint.replaceConstraintSubPart(subConstraint, substituteExpressions(subConstraint, result)); + } + } + return constraint; + } + + private static Constraint removeImplication(Constraint constraint){ + if (constraint instanceof ImplicationConstraint) { + return new OrConstraint( + new NotConstraint( + removeImplication(((ImplicationConstraint) constraint).getLeft())), + removeImplication(((ImplicationConstraint) constraint).getRight()) + ); + }else{ + for (Constraint subConstraint : constraint.getConstraintSubParts()){ + constraint.replaceConstraintSubPart(subConstraint, removeImplication(subConstraint)); + } + } + return constraint; + } + + private static Constraint removeBiimplication(Constraint constraint){ + if (constraint instanceof EquivalenceConstraint) { + return new AndConstraint( + new OrConstraint( + new NotConstraint( + removeBiimplication(((EquivalenceConstraint) constraint).getLeft()) + ), + removeBiimplication(((EquivalenceConstraint) constraint).getRight())), + new OrConstraint( + new NotConstraint( + removeBiimplication(((EquivalenceConstraint) constraint).getRight())), + removeBiimplication(((EquivalenceConstraint) constraint).getLeft())) + ); + }else{ + for (Constraint subConstraint : constraint.getConstraintSubParts()){ + constraint.replaceConstraintSubPart(subConstraint, removeBiimplication(subConstraint)); + } + } + return constraint; + } + + private static Constraint pushDownNegation(Constraint constraint){ + if (constraint instanceof NotConstraint) { + var notConstraint = (NotConstraint) constraint; + if (notConstraint.getContent() instanceof AndConstraint){ + return pushDownNegation( + new OrConstraint( + new NotConstraint(((AndConstraint) notConstraint.getContent()).getLeft()), + new NotConstraint(((AndConstraint) notConstraint.getContent()).getRight()) + ) + ); + }else if (notConstraint.getContent() instanceof OrConstraint){ + return pushDownNegation( + new AndConstraint( + new NotConstraint(((OrConstraint) notConstraint.getContent()).getLeft()), + new NotConstraint(((OrConstraint) notConstraint.getContent()).getRight()) + ) + ); + }else if (notConstraint.getContent() instanceof NotConstraint){ + return pushDownNegation( + ((NotConstraint) notConstraint.getContent()).getContent() + ); + }else { + return notConstraint; + } + }else { + for (Constraint subConstraint : constraint.getConstraintSubParts()){ + constraint.replaceConstraintSubPart(subConstraint, pushDownNegation(subConstraint)); + } + } + return constraint; + } + + public static void encodeConstraintTseitinStyle(Constraint constraint, OPBResult result){ + if (constraint instanceof LiteralConstraint){ + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = 1; + Literal literal = new Literal(1, ((LiteralConstraint) constraint).getReference().getIdentifier(), true); + pbConstraint.literalList.add(literal); + result.numberVariables++; + pbConstraint.toOPBString(result); + return; + } + HashMap subMap = new HashMap<>(); + constraint.extractTseitinSubConstraints(subMap); + + if (subMap.isEmpty()) { + if (constraint instanceof LiteralConstraint){ + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = 1; + Literal literal = new Literal(1, ((LiteralConstraint) constraint).getReference().getIdentifier(), true); + pbConstraint.literalList.add(literal); + result.numberVariables++; + pbConstraint.toOPBString(result); + return; + }else if(constraint instanceof NotConstraint){ + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = 0; + Literal literal = new Literal(-1, ((LiteralConstraint)((NotConstraint)constraint).getContent()).getReference().getIdentifier(), true); + pbConstraint.literalList.add(literal); + result.numberVariables++; + pbConstraint.toOPBString(result); + return; + } + } + + boolean sign = !(constraint instanceof NotConstraint); + Literal literal = new Literal(1, "x_" + SubstitutionVariableIndex.getInstance().peekIndex(), sign); + + List additionalSubstitutionConstraints = new LinkedList<>(); + var map = transformSubFormulas(subMap, additionalSubstitutionConstraints); + List pbcList = transformImplicationMap(map); + PBConstraint pbConstraint = new PBConstraint(); + pbConstraint.literalList = new LinkedList<>(); + pbConstraint.k = 1; + + pbConstraint.literalList.add(literal); + pbcList.add(pbConstraint); + pbcList.addAll(additionalSubstitutionConstraints); + for(PBConstraint pBConstraint : pbcList){ + result.numberVariables++; + pBConstraint.toOPBString(result); + } + } + + private static Constraint distributeOrOverAnd(Constraint constraint) { + if (constraint instanceof OrConstraint) { + OrConstraint or = (OrConstraint) constraint; + Constraint left = distributeOrOverAnd(or.getLeft()); + Constraint right = distributeOrOverAnd(or.getRight()); + + if (left instanceof AndConstraint) { + AndConstraint leftAnd = (AndConstraint) left; + return new AndConstraint( + distributeOrOverAnd(new OrConstraint(leftAnd.getLeft(), right)), + distributeOrOverAnd(new OrConstraint(leftAnd.getRight(), right)) + ); + } else if (right instanceof AndConstraint) { + AndConstraint rightAnd = (AndConstraint) right; + return new AndConstraint( + distributeOrOverAnd(new OrConstraint(left, rightAnd.getLeft())), + distributeOrOverAnd(new OrConstraint(left, rightAnd.getRight())) + ); + } + return new OrConstraint(left, right); + } else if (constraint instanceof AndConstraint) { + + AndConstraint and = (AndConstraint) constraint; + return new AndConstraint( + distributeOrOverAnd(and.getLeft()), + distributeOrOverAnd(and.getRight()) + ); + } + + return constraint; + } + } From e63866c61b04d4bc1dc6e5d566ea35d7c84f0733 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 5 Dec 2024 10:51:49 +0100 Subject: [PATCH 46/60] feat: added support for distributive opb encoding --- src/main/java/de/vill/main/Eval.java | 106 ++++++++++++++--- src/main/java/de/vill/model/FeatureModel.java | 99 +++++++++++++++- .../vill/model/constraint/AndConstraint.java | 17 +++ .../de/vill/model/constraint/Constraint.java | 3 + .../constraint/EquivalenceConstraint.java | 12 ++ .../constraint/ExpressionConstraint.java | 7 ++ .../constraint/ImplicationConstraint.java | 9 ++ .../model/constraint/LiteralConstraint.java | 9 ++ .../model/constraint/MultiOrConstraint.java | 8 ++ .../vill/model/constraint/NotConstraint.java | 10 ++ .../vill/model/constraint/OrConstraint.java | 18 +++ .../constraint/ParenthesisConstraint.java | 7 ++ src/main/java/de/vill/util/Util.java | 109 ++++++++++++------ 13 files changed, 357 insertions(+), 57 deletions(-) diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java index 8ed34ed..6db8591 100644 --- a/src/main/java/de/vill/main/Eval.java +++ b/src/main/java/de/vill/main/Eval.java @@ -2,8 +2,13 @@ import de.ovgu.featureide.fm.core.ExtensionManager; +import de.ovgu.featureide.fm.core.analysis.cnf.CNF; +import de.ovgu.featureide.fm.core.analysis.cnf.Nodes; +import de.ovgu.featureide.fm.core.analysis.cnf.Variables; +import de.ovgu.featureide.fm.core.base.FeatureUtils; import de.ovgu.featureide.fm.core.base.IFeatureModel; import de.ovgu.featureide.fm.core.base.impl.*; +import de.ovgu.featureide.fm.core.editing.AdvancedNodeCreator; import de.ovgu.featureide.fm.core.init.FMCoreLibrary; import de.ovgu.featureide.fm.core.init.LibraryManager; import de.ovgu.featureide.fm.core.io.IPersistentFormat; @@ -12,8 +17,9 @@ import de.ovgu.featureide.fm.core.io.manager.FeatureModelManager; import de.ovgu.featureide.fm.core.io.manager.FileHandler; import de.ovgu.featureide.fm.core.io.uvl.UVLFeatureModelFormat; +import de.vill.model.*; +import de.vill.model.Feature; import de.vill.model.FeatureModel; -import de.vill.model.LanguageLevel; import de.vill.util.ConvertFeatureCardinalityForOPB; import de.vill.util.CountingResult; import de.vill.util.ModelEvalResult; @@ -27,22 +33,78 @@ import java.util.List; import java.util.Set; +import static java.awt.SystemColor.text; + public class Eval { public static final String WORKING_DIR = "/home/stefan/stefan-vill-master/tmp_eval/"; public static final String D4_PATH = "/home/stefan/Downloads/d4/d4"; public static final String P2D_PATH = "/home/stefan/p2d/target/release/p2d"; + final static long NUMBER_RUNS = 1; + public static boolean tseitin = false; + + public static FeatureModel genGroupCardN(int n){ + int lo = (int) (0.25 * n); + int hi = (int) (0.75 * n); + FeatureModel featureModel = new FeatureModel(); + Feature root = new Feature("r"); + featureModel.setRootFeature(root); + Group g = new Group(Group.GroupType.GROUP_CARDINALITY); + g.setCardinality(new Cardinality(lo, hi)); + root.getChildren().add(g); + for (int i=1;i<=n;i++){ + Feature f = new Feature("f_" + i); + g.getFeatures().add(f); + } + return featureModel; + } + + public static void safeFMGroupCardFrom1ToN(String path, int n) throws FileNotFoundException { + for (int i=1;i<=n;i++){ + FeatureModel fm = genGroupCardN(i); + try (PrintWriter out = new PrintWriter(path + "/fm_" + i + ".uvl")) { + out.println(fm.toString()); + } + } + } public static void main(String[] args) throws IOException, InterruptedException { - //runSingleFile("test.uvl"); - //bs("/test.uvl"); - runEval(); + //runSingleFile("./models/automotive01.uvl"); + //bs("rnd_models/fm0.uvl"); + //runEval(); + + //safeFMGroupCardFrom1ToN("/home/stefan/stefan-vill-master/eval/genGroupCardModel", 10); + + //System.exit(0); + + final File UVL_FILE = new File(args[0]); + final File TARGET_FILE = new File(args[1]); + final Target target = args[2].equals("dimacs") ? Target.DIMACS : Target.OPB; + tseitin = args[3] != null && args[3].equals("tseitin"); + + switch (target) { + case DIMACS: { + uvlToDimacsFeatureIDE(UVL_FILE, TARGET_FILE); + break; + } + case OPB: { + uvlToOPB(UVL_FILE, TARGET_FILE); + break; + } + } + + } + + public static enum Target{ + DIMACS, + OPB } public static void bs(String modelName)throws IOException, InterruptedException { File file = Paths.get(WORKING_DIR, modelName).toFile(); - uvlToOPB(file); + File opbTargetFile = Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".opb").toFile(); + uvlToOPB(file, opbTargetFile); runp2d(file); } public static void runSingleFile(String modelName) throws IOException, InterruptedException { @@ -53,7 +115,6 @@ public static void runSingleFile(String modelName) throws IOException, Interrupt } public static void runEval() throws IOException, InterruptedException { - final int NUMBER_RUNS = 3; List resultList = new LinkedList<>(); File folder = Paths.get(WORKING_DIR, "models").toFile(); File[] files = folder.listFiles(); @@ -88,10 +149,11 @@ public static void runEval() throws IOException, InterruptedException { public static ModelEvalResult evaluateModel(File file) throws IOException, InterruptedException { double totalTimeDimacs = 0; - final long NUMBER_RUNS = 3; + File dimacsTargetFile = Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".dimacs").toFile(); + File opbTargetFile = Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".opb").toFile(); for (int i=0;i levels = new HashSet<>(); levels.add(LanguageLevel.AGGREGATE_FUNCTION); levels.add( LanguageLevel.STRING_CONSTRAINTS); uvlModelFactory.convertLanguageLevel(featureModel, levels); - try (BufferedWriter writer = new BufferedWriter(new FileWriter(Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".opb").toString()))) { - writer.append(featureModel.toOPBString()); + + try (BufferedWriter writer = new BufferedWriter(new FileWriter(targetFile))) { + if (tseitin) { + writer.append(featureModel.toOPBString()); + }else{ + featureModel.writeOPBStringToFile(modelFile, targetFile,writer); + } writer.flush(); } catch (IOException e) { System.err.println("Error writing to file: " + e.getMessage()); } } - public static void uvlToDimacsFeatureIDE(File file) throws IOException { + public static void uvlToDimacsFeatureIDE(File modelFile, File targetFile) throws IOException { UVLModelFactory uvlModelFactory = new UVLModelFactory(); - FeatureModel featureModel = loadUVLFeatureModelFromFile(file.toString()); + FeatureModel featureModel = loadUVLFeatureModelFromFile(modelFile.toString()); Set levels = new HashSet<>(); levels.add(LanguageLevel.BOOLEAN_LEVEL); - levels.add( LanguageLevel.TYPE_LEVEL); + levels.add(LanguageLevel.TYPE_LEVEL); uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); LibraryManager.registerLibrary(FMCoreLibrary.getInstance()); FMFormatManager.getInstance().addExtension(new UVLFeatureModelFormat()); - IFeatureModel fm = getFeatureIdeFMFromString(file.toPath(), featureModel.toString()); - FileHandler.save(Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".dimacs"), fm, new DIMACSFormat()); + IFeatureModel fm = getFeatureIdeFMFromString(modelFile.toPath(), featureModel.toString()); + FileHandler.save(targetFile.toPath(), fm, new DIMACSFormat()); } diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 493528f..4f34bb1 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -1,5 +1,7 @@ package de.vill.model; +import java.io.*; +import java.nio.file.Path; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; @@ -9,6 +11,20 @@ import java.util.Optional; import java.util.Set; +import de.ovgu.featureide.fm.core.ExtensionManager; +import de.ovgu.featureide.fm.core.analysis.cnf.CNF; +import de.ovgu.featureide.fm.core.analysis.cnf.LiteralSet; +import de.ovgu.featureide.fm.core.analysis.cnf.Nodes; +import de.ovgu.featureide.fm.core.analysis.cnf.Variables; +import de.ovgu.featureide.fm.core.base.FeatureUtils; +import de.ovgu.featureide.fm.core.base.IFeatureModel; +import de.ovgu.featureide.fm.core.base.impl.FMFactoryManager; +import de.ovgu.featureide.fm.core.base.impl.FMFormatManager; +import de.ovgu.featureide.fm.core.editing.AdvancedNodeCreator; +import de.ovgu.featureide.fm.core.init.FMCoreLibrary; +import de.ovgu.featureide.fm.core.init.LibraryManager; +import de.ovgu.featureide.fm.core.io.manager.FileHandler; +import de.ovgu.featureide.fm.core.io.uvl.UVLFeatureModelFormat; import de.vill.config.Configuration; import de.vill.model.constraint.Constraint; import de.vill.model.constraint.LiteralConstraint; @@ -16,11 +32,14 @@ import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; import de.vill.model.expression.LiteralExpression; -import de.vill.model.pbc.Literal; import de.vill.model.pbc.OPBResult; import de.vill.model.pbc.PBConstraint; import de.vill.util.SubstitutionVariableIndex; import de.vill.util.Util; +import org.prop4j.And; +import org.prop4j.Literal; +import org.prop4j.Node; +import org.prop4j.Or; import static de.vill.util.Util.*; @@ -271,8 +290,8 @@ public StringBuilder toOPBString(){ constraints.addAll(getFeatureConstraints()); for(Constraint constraint : constraints){ - constraintDistributiveToOPB(constraint,result); - //encodeConstraintTseitinStyle(constraint, result); + //constraintDistributiveToOPB(constraint,result); + encodeConstraintTseitinStyle(constraint, result); } SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); @@ -283,6 +302,80 @@ public StringBuilder toOPBString(){ return result.opbString; } + public void writeOPBStringToFile(File fmFile, File opbFile, Writer writer) throws IOException { + OPBResult result = new OPBResult(); + result.numberVariables++; + result.opbString.append(getRootFeature().getQuotedFeatureName()); + result.opbString.append(" >= 1;\n"); + result.numberConstraints++; + getRootFeature().toOPBString(result); + + SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); + result.numberVariables += substitutionVariableIndex.peekIndex(); + String header = "#variable= " + result.numberVariables + " #constraint= " + result.numberConstraints + "\n"; + result.opbString.insert(0,header); + + List constraints = getConstraints(); + constraints.addAll(getFeatureConstraints()); + + for (Constraint constraint : constraints){ + var cnfConstraint = substituteExpressions(constraint, result).getNode().toCNF(); + List clauses = new LinkedList<>(); + if (cnfConstraint instanceof And) { + for(Node andChild : cnfConstraint.getChildren()){ + if (!(andChild instanceof Or)){ + clauses.add(new Or(andChild)); + }else{ + clauses.add(andChild); + } + } + }else{ + if (!(cnfConstraint instanceof Or)){ + clauses.add(new Or(cnfConstraint)); + }else{ + clauses.add(cnfConstraint); + } + } + for (Node clause : clauses){ + int negationCount = 0; + for (Literal literal : clause.getLiterals()) { + String variableName = (String)literal.var; + if (literal.positive){ + result.opbString.append(" +1 * "); + }else{ + result.opbString.append(" -1 * "); + negationCount++; + } + + result.opbString.append("\""); + result.opbString.append(variableName); + result.opbString.append("\""); + } + result.opbString.append(" >= "); + result.opbString.append(String.valueOf(1 - negationCount)); + result.opbString.append(";\n"); + } + } + + writer.append(result.opbString); + + } + + private IFeatureModel getFeatureIdeFMFromString(Path path, String content) throws IOException { + final FileHandler fileHandler = new FileHandler<>(path, null, null); + final UVLFeatureModelFormat format = new UVLFeatureModelFormat(); + try { + final IFeatureModel fm = FMFactoryManager.getInstance().getFactory(path, format).create(); + fileHandler.setObject(fm); + fileHandler.setFormat(format); + format.getInstance().read(fm, content, path); + + }catch (ExtensionManager.NoSuchExtensionException e) { + throw new IOException("Error while parsing UVL model"); + } + return fileHandler.getObject(); + } + public StringBuilder toSMT2string() { StringBuilder builder = new StringBuilder(); builder.append("(set-logic QF_UF)\n"); diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index 2bc03c3..be4a0be 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -3,6 +3,8 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.PBCLiteralConstraint; import de.vill.util.SubstitutionVariableIndex; +import org.prop4j.And; +import org.prop4j.Node; import java.util.*; @@ -26,6 +28,21 @@ public Constraint getRight() { return right; } + public void setLeft(Constraint left) { + this.left = left; + } + + public void setRight(Constraint right){ + this.right = right; + } + + @Override + public Node getNode() { + var node = new And(); + node.setChildren(left.getNode(), right.getNode()); + return node; + } + @Override public String toString(boolean withSubmodels, String currentAlias) { return left.toString(withSubmodels, currentAlias) + diff --git a/src/main/java/de/vill/model/constraint/Constraint.java b/src/main/java/de/vill/model/constraint/Constraint.java index f3cc75c..0cb308f 100644 --- a/src/main/java/de/vill/model/constraint/Constraint.java +++ b/src/main/java/de/vill/model/constraint/Constraint.java @@ -3,6 +3,7 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.Literal; import de.vill.model.pbc.PBCLiteralConstraint; +import org.prop4j.Node; import java.util.HashMap; import java.util.LinkedList; @@ -20,6 +21,8 @@ public void setLineNumber(int lineNumber) { private int lineNumber; + public abstract Node getNode(); + @Override public String toString() { return toString(true, ""); diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index 8078942..f6f591e 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -3,6 +3,9 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.PBCLiteralConstraint; import de.vill.util.SubstitutionVariableIndex; +import org.prop4j.And; +import org.prop4j.Implies; +import org.prop4j.Node; import java.util.*; @@ -109,4 +112,13 @@ public StringBuilder toSMT2string() { return builder; } + @Override + public Node getNode() { + var node = new And( + new Implies(left.getNode(), right.getNode()), + new Implies(right.getNode(), left.getNode()) + ); + return node; + } + } diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index 79dbe50..75617a2 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -8,6 +8,8 @@ import de.vill.model.pbc.Literal; import de.vill.model.pbc.PBCLiteralConstraint; import de.vill.util.SubstitutionVariableIndex; +import org.prop4j.And; +import org.prop4j.Node; import java.util.*; @@ -146,4 +148,9 @@ public String getIdentifier() { }) ); } + + @Override + public Node getNode() { + return null; + } } diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index d5bbc67..de2b740 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -3,6 +3,9 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.PBCLiteralConstraint; import de.vill.util.SubstitutionVariableIndex; +import org.prop4j.And; +import org.prop4j.Implies; +import org.prop4j.Node; import java.util.*; @@ -107,4 +110,10 @@ public StringBuilder toSMT2string() { builder.append(")"); return builder; } + + @Override + public Node getNode() { + var node = new Implies(left.getNode(), right.getNode()); + return node; + } } diff --git a/src/main/java/de/vill/model/constraint/LiteralConstraint.java b/src/main/java/de/vill/model/constraint/LiteralConstraint.java index d98897f..a8df29c 100644 --- a/src/main/java/de/vill/model/constraint/LiteralConstraint.java +++ b/src/main/java/de/vill/model/constraint/LiteralConstraint.java @@ -4,6 +4,9 @@ import de.vill.model.pbc.PBCLiteralConstraint; import de.vill.util.SubstitutionVariableIndex; import de.vill.util.Util; +import org.prop4j.And; +import org.prop4j.Literal; +import org.prop4j.Node; import java.util.HashMap; import java.util.List; @@ -77,4 +80,10 @@ public StringBuilder toSMT2string() { public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { return new PBCLiteralConstraint(this); } + + @Override + public Node getNode() { + var node = new Literal(reference.getIdentifier(), true); + return node; + } } diff --git a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java index 7fd1cf7..ed44a4a 100644 --- a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java +++ b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java @@ -2,6 +2,7 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.PBCLiteralConstraint; +import org.prop4j.Node; import java.util.*; @@ -13,6 +14,11 @@ public MultiOrConstraint() { sub_parts = new LinkedList<>(); } + @Override + public Node getNode() { + return null; + } + @Override public String toString(boolean withSubmodels, String currentAlias) { StringBuilder result = new StringBuilder(); @@ -111,4 +117,6 @@ public StringBuilder toSMT2string() { builder.append(")"); return builder; } + + } diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index 70f2c77..f4c3879 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -2,6 +2,10 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.PBCLiteralConstraint; +import org.prop4j.And; +import org.prop4j.Node; +import org.prop4j.Not; +import org.prop4j.Or; import java.util.*; @@ -98,4 +102,10 @@ public StringBuilder toSMT2string() { builder.append(")"); return builder; } + + @Override + public Node getNode() { + var node = new Not(content.getNode()); + return node; + } } diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index ab78465..559fe16 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -3,6 +3,9 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.PBCLiteralConstraint; import de.vill.util.SubstitutionVariableIndex; +import org.prop4j.And; +import org.prop4j.Node; +import org.prop4j.Or; import java.util.*; @@ -26,6 +29,14 @@ public Constraint getRight() { return right; } + public void setLeft(Constraint left) { + this.left = left; + } + + public void setRight(Constraint right){ + this.right = right; + } + @Override public String toString(boolean withSubmodels, String currentAlias) { return left.toString(withSubmodels, currentAlias) + @@ -107,4 +118,11 @@ public StringBuilder toSMT2string() { builder.append(")"); return builder; } + + @Override + public Node getNode() { + var node = new Or(); + node.setChildren(left.getNode(), right.getNode()); + return node; + } } diff --git a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java index bb4a3f6..d62e0c0 100644 --- a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java +++ b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java @@ -2,6 +2,8 @@ import de.vill.model.building.VariableReference; import de.vill.model.pbc.PBCLiteralConstraint; +import org.prop4j.And; +import org.prop4j.Node; import java.util.*; @@ -72,4 +74,9 @@ public StringBuilder toSMT2string() { builder.append(content.toSMT2string()); return builder; } + + @Override + public Node getNode() { + return content.getNode(); + } } diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index d14b048..9139749 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -1,12 +1,14 @@ package de.vill.util; import de.vill.config.Configuration; +import de.vill.conversion.ConvertAggregateFunction; import de.vill.model.building.VariableReference; import de.vill.model.constraint.*; import de.vill.model.expression.*; import de.vill.model.pbc.*; import java.io.IOException; +import java.io.Writer; import java.nio.file.Files; import java.nio.file.Path; import java.util.HashMap; @@ -386,63 +388,72 @@ public static List getConstraintsToForbidZeroDivision(List= "); - stringBuilder.append(1 - negatives); - stringBuilder.append(";\n"); + int negatives = clauseToOpb(constraint, writer); + writer.write(" >= "); + writer.write(String.valueOf(1 - negatives)); + writer.write(";\n"); }else { var and = (AndConstraint) constraint; if (and.getLeft() instanceof AndConstraint){ - cnfToOpb(and.getLeft(), stringBuilder); + cnfToOpb(and.getLeft(), writer); }else{ - int negatives = clauseToOpb(and.getLeft(), stringBuilder); - stringBuilder.append(" >= "); - stringBuilder.append(1 - negatives); - stringBuilder.append(";\n"); + int negatives = clauseToOpb(and.getLeft(), writer); + writer.write(" >= "); + writer.write(String.valueOf(1 - negatives)); + writer.write(";\n"); } if (and.getRight() instanceof AndConstraint){ - cnfToOpb(and.getRight(), stringBuilder); + cnfToOpb(and.getRight(), writer); }else{ - int negatives = clauseToOpb(and.getRight(), stringBuilder); - stringBuilder.append(" >= "); - stringBuilder.append(1 - negatives); - stringBuilder.append(";\n"); + int negatives = clauseToOpb(and.getRight(), writer); + writer.write(" >= "); + writer.write(String.valueOf(1 - negatives)); + writer.write(";\n"); } } } - private static int clauseToOpb(Constraint constraint, StringBuilder stringBuilder) { + private static int clauseToOpb(Constraint constraint, Writer writer) throws IOException { int negatives = 0; if (constraint instanceof NotConstraint) { - stringBuilder.append(" -1 * "); + writer.write(" -1 * "); var literal = (LiteralConstraint)((NotConstraint) constraint).getContent(); - stringBuilder.append('"'); - stringBuilder.append(literal.getReference().getIdentifier()); - stringBuilder.append('"'); + writer.write('"'); + writer.write(literal.getReference().getIdentifier()); + writer.write('"'); negatives++; }else if (constraint instanceof LiteralConstraint){ - stringBuilder.append(" +1 * "); + writer.append(" +1 * "); var literal = (LiteralConstraint)constraint; - stringBuilder.append('"'); - stringBuilder.append(literal.getReference().getIdentifier()); - stringBuilder.append('"'); + writer.write('"'); + writer.write(literal.getReference().getIdentifier()); + writer.write('"'); }else { var or = (OrConstraint)constraint; - negatives += clauseToOpb(or.getLeft(), stringBuilder); - negatives += clauseToOpb(or.getRight(), stringBuilder); + negatives += clauseToOpb(or.getLeft(), writer); + negatives += clauseToOpb(or.getRight(), writer); } return negatives; } @@ -458,7 +469,7 @@ private static Constraint removeParenthesisConstraint(Constraint constraint){ return constraint; } - private static Constraint substituteExpressions(Constraint constraint, OPBResult result){ + public static Constraint substituteExpressions(Constraint constraint, OPBResult result){ if (constraint instanceof ExpressionConstraint){ SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); int subIndex = substitutionVariableIndex.getIndex(); @@ -610,33 +621,61 @@ public static void encodeConstraintTseitinStyle(Constraint constraint, OPBResult } } - private static Constraint distributeOrOverAnd(Constraint constraint) { + private static Constraint distributeOrOverAnd(Constraint constraint, int d) { + if (counter == 74 && d >= 20) { + System.out.println("test"); + } + d++; if (constraint instanceof OrConstraint) { OrConstraint or = (OrConstraint) constraint; - Constraint left = distributeOrOverAnd(or.getLeft()); - Constraint right = distributeOrOverAnd(or.getRight()); + Constraint left = distributeOrOverAnd(or.getLeft(), d); + Constraint right = distributeOrOverAnd(or.getRight(), d); if (left instanceof AndConstraint) { AndConstraint leftAnd = (AndConstraint) left; + leftAnd.setLeft(distributeOrOverAnd(new OrConstraint(leftAnd.getLeft(), right),d)); + leftAnd.setRight(distributeOrOverAnd(new OrConstraint(leftAnd.getRight(), right),d)); + return leftAnd; + /* return new AndConstraint( distributeOrOverAnd(new OrConstraint(leftAnd.getLeft(), right)), distributeOrOverAnd(new OrConstraint(leftAnd.getRight(), right)) ); + + */ } else if (right instanceof AndConstraint) { AndConstraint rightAnd = (AndConstraint) right; + rightAnd.setLeft(distributeOrOverAnd(new OrConstraint(left, rightAnd.getLeft()),d)); + rightAnd.setRight(distributeOrOverAnd(new OrConstraint(left, rightAnd.getRight()),d)); + return rightAnd; + /* return new AndConstraint( distributeOrOverAnd(new OrConstraint(left, rightAnd.getLeft())), distributeOrOverAnd(new OrConstraint(left, rightAnd.getRight())) ); + + */ } - return new OrConstraint(left, right); + // + or.setLeft(left); + or.setRight(right); + return constraint; + //return new OrConstraint(left, right); } else if (constraint instanceof AndConstraint) { - + // AndConstraint and = (AndConstraint) constraint; + Constraint left = distributeOrOverAnd(and.getLeft(),d); + Constraint right = distributeOrOverAnd(and.getRight(),d); + and.setLeft(left); + and.setRight(right); + return and; + /* return new AndConstraint( distributeOrOverAnd(and.getLeft()), distributeOrOverAnd(and.getRight()) ); + + */ } return constraint; From f1b9c8f02816e011cc28b702d4aa7cb70ba23d01 Mon Sep 17 00:00:00 2001 From: Stefan Date: Tue, 17 Dec 2024 10:17:07 +0100 Subject: [PATCH 47/60] fix: set quotes for feature name "false" --- src/main/java/de/vill/util/Util.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 9139749..3f17589 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -37,6 +37,10 @@ public static String addNecessaryQuotes(String reference) { result.append("\""); result.append(part); result.append("\""); + } else if(part.equals("false")) { + result.append("\""); + result.append(part); + result.append("\""); } else { result.append(part); } From 83b103f3905369c2b16439f770cdbdf7ee52cd5f Mon Sep 17 00:00:00 2001 From: Stefan Date: Wed, 18 Dec 2024 12:24:13 +0100 Subject: [PATCH 48/60] refactor: moved all pseudo-boolean related code into another project --- pom.xml | 7 +- src/main/java/de/vill/main/Eval.java | 349 ---------- src/main/java/de/vill/main/Example.java | 119 ++-- src/main/java/de/vill/model/Feature.java | 113 +--- src/main/java/de/vill/model/FeatureModel.java | 156 +---- src/main/java/de/vill/model/Group.java | 72 -- .../vill/model/constraint/AndConstraint.java | 51 +- .../de/vill/model/constraint/Constraint.java | 22 - .../constraint/EquivalenceConstraint.java | 50 +- .../constraint/ExpressionConstraint.java | 33 - .../constraint/ImplicationConstraint.java | 44 +- .../model/constraint/LiteralConstraint.java | 25 - .../model/constraint/MultiOrConstraint.java | 31 +- .../vill/model/constraint/NotConstraint.java | 42 +- .../vill/model/constraint/OrConstraint.java | 47 +- .../constraint/ParenthesisConstraint.java | 23 +- .../vill/model/expression/AddExpression.java | 11 - .../AggregateFunctionExpression.java | 16 +- .../vill/model/expression/DivExpression.java | 71 -- .../de/vill/model/expression/Expression.java | 6 - .../LengthAggregateFunctionExpression.java | 7 - .../model/expression/LiteralExpression.java | 18 +- .../vill/model/expression/MulExpression.java | 49 -- .../model/expression/NumberExpression.java | 9 - .../expression/ParenthesisExpression.java | 7 - .../model/expression/StringExpression.java | 7 - .../vill/model/expression/SubExpression.java | 12 - src/main/java/de/vill/model/pbc/Literal.java | 36 - .../java/de/vill/model/pbc/OPBResult.java | 7 - .../vill/model/pbc/PBCLiteralConstraint.java | 19 - .../java/de/vill/model/pbc/PBConstraint.java | 180 ----- .../de/vill/model/pbc/PBConstraintType.java | 25 - .../util/ConvertFeatureCardinalityForOPB.java | 266 -------- .../java/de/vill/util/CountingResult.java | 11 - .../java/de/vill/util/ModelEvalResult.java | 27 - .../vill/util/SubstitutionVariableIndex.java | 30 - src/main/java/de/vill/util/Util.java | 637 ------------------ 37 files changed, 103 insertions(+), 2532 deletions(-) delete mode 100644 src/main/java/de/vill/main/Eval.java delete mode 100644 src/main/java/de/vill/model/pbc/Literal.java delete mode 100644 src/main/java/de/vill/model/pbc/OPBResult.java delete mode 100644 src/main/java/de/vill/model/pbc/PBCLiteralConstraint.java delete mode 100644 src/main/java/de/vill/model/pbc/PBConstraint.java delete mode 100644 src/main/java/de/vill/model/pbc/PBConstraintType.java delete mode 100644 src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java delete mode 100644 src/main/java/de/vill/util/CountingResult.java delete mode 100644 src/main/java/de/vill/util/ModelEvalResult.java delete mode 100644 src/main/java/de/vill/util/SubstitutionVariableIndex.java diff --git a/pom.xml b/pom.xml index e80c7b4..a5e826f 100644 --- a/pom.xml +++ b/pom.xml @@ -92,11 +92,6 @@ uvl 1.0.0 - - de.ovgu.featureide - featureide - 1.0.0 - org.antlr antlr @@ -116,7 +111,7 @@ - de.vill.main.Eval + de.vill.main.Example diff --git a/src/main/java/de/vill/main/Eval.java b/src/main/java/de/vill/main/Eval.java deleted file mode 100644 index 6db8591..0000000 --- a/src/main/java/de/vill/main/Eval.java +++ /dev/null @@ -1,349 +0,0 @@ -package de.vill.main; - - -import de.ovgu.featureide.fm.core.ExtensionManager; -import de.ovgu.featureide.fm.core.analysis.cnf.CNF; -import de.ovgu.featureide.fm.core.analysis.cnf.Nodes; -import de.ovgu.featureide.fm.core.analysis.cnf.Variables; -import de.ovgu.featureide.fm.core.base.FeatureUtils; -import de.ovgu.featureide.fm.core.base.IFeatureModel; -import de.ovgu.featureide.fm.core.base.impl.*; -import de.ovgu.featureide.fm.core.editing.AdvancedNodeCreator; -import de.ovgu.featureide.fm.core.init.FMCoreLibrary; -import de.ovgu.featureide.fm.core.init.LibraryManager; -import de.ovgu.featureide.fm.core.io.IPersistentFormat; -import de.ovgu.featureide.fm.core.io.Problem; -import de.ovgu.featureide.fm.core.io.dimacs.DIMACSFormat; -import de.ovgu.featureide.fm.core.io.manager.FeatureModelManager; -import de.ovgu.featureide.fm.core.io.manager.FileHandler; -import de.ovgu.featureide.fm.core.io.uvl.UVLFeatureModelFormat; -import de.vill.model.*; -import de.vill.model.Feature; -import de.vill.model.FeatureModel; -import de.vill.util.ConvertFeatureCardinalityForOPB; -import de.vill.util.CountingResult; -import de.vill.util.ModelEvalResult; - -import java.io.*; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.HashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Set; - -import static java.awt.SystemColor.text; - -public class Eval { - - public static final String WORKING_DIR = "/home/stefan/stefan-vill-master/tmp_eval/"; - public static final String D4_PATH = "/home/stefan/Downloads/d4/d4"; - public static final String P2D_PATH = "/home/stefan/p2d/target/release/p2d"; - final static long NUMBER_RUNS = 1; - public static boolean tseitin = false; - - public static FeatureModel genGroupCardN(int n){ - int lo = (int) (0.25 * n); - int hi = (int) (0.75 * n); - FeatureModel featureModel = new FeatureModel(); - Feature root = new Feature("r"); - featureModel.setRootFeature(root); - Group g = new Group(Group.GroupType.GROUP_CARDINALITY); - g.setCardinality(new Cardinality(lo, hi)); - root.getChildren().add(g); - for (int i=1;i<=n;i++){ - Feature f = new Feature("f_" + i); - g.getFeatures().add(f); - } - return featureModel; - } - - public static void safeFMGroupCardFrom1ToN(String path, int n) throws FileNotFoundException { - for (int i=1;i<=n;i++){ - FeatureModel fm = genGroupCardN(i); - try (PrintWriter out = new PrintWriter(path + "/fm_" + i + ".uvl")) { - out.println(fm.toString()); - } - } - } - - public static void main(String[] args) throws IOException, InterruptedException { - //runSingleFile("./models/automotive01.uvl"); - //bs("rnd_models/fm0.uvl"); - //runEval(); - - //safeFMGroupCardFrom1ToN("/home/stefan/stefan-vill-master/eval/genGroupCardModel", 10); - - //System.exit(0); - - final File UVL_FILE = new File(args[0]); - final File TARGET_FILE = new File(args[1]); - final Target target = args[2].equals("dimacs") ? Target.DIMACS : Target.OPB; - tseitin = args[3] != null && args[3].equals("tseitin"); - - switch (target) { - case DIMACS: { - uvlToDimacsFeatureIDE(UVL_FILE, TARGET_FILE); - break; - } - case OPB: { - uvlToOPB(UVL_FILE, TARGET_FILE); - break; - } - } - - } - - public static enum Target{ - DIMACS, - OPB - - } - - public static void bs(String modelName)throws IOException, InterruptedException { - File file = Paths.get(WORKING_DIR, modelName).toFile(); - File opbTargetFile = Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".opb").toFile(); - uvlToOPB(file, opbTargetFile); - runp2d(file); - } - public static void runSingleFile(String modelName) throws IOException, InterruptedException { - File file = Paths.get(WORKING_DIR, modelName).toFile(); - ModelEvalResult result = evaluateModel(file); - System.out.println("name;d4 time;p2d time;dimacs encoding time; opb encoding time; same result;solving-factor;encoding-factor;total-factor"); - System.out.println(result.toCSVString()); - } - - public static void runEval() throws IOException, InterruptedException { - List resultList = new LinkedList<>(); - File folder = Paths.get(WORKING_DIR, "models").toFile(); - File[] files = folder.listFiles(); - for (File f : files) { - List tmpResultList = new LinkedList<>(); - for (int i=0;i x.TIME_TO_COMPUTE_D4).sum() / NUMBER_RUNS, - tmpResultList.stream().mapToDouble(x -> x.TIME_TO_COMPUTE_P2D).sum() / NUMBER_RUNS, - tmpResultList.get(0).MODEL_COUNT_D4, - tmpResultList.get(0).MODEL_COUNT_P2D, - tmpResultList.get(0).SAME_RESULT, - tmpResultList.stream().mapToDouble(x -> x.TO_DIMACS_TIME).sum() / NUMBER_RUNS, - tmpResultList.stream().mapToDouble(x -> x.TO_OPB_TIME).sum() / NUMBER_RUNS - )); - } - StringBuilder result = new StringBuilder(); - result.append("name;d4 time;p2d time;dimacs encoding time; opb encoding time; same result;solving-factor;encoding-factor;total-factor\n"); - for (ModelEvalResult r : resultList) { - result.append(r.toCSVString()); - result.append("\n"); - } - try (BufferedWriter writer = new BufferedWriter(new FileWriter(Paths.get(WORKING_DIR, "result.csv").toString()))) { - writer.append(result); - writer.flush(); - } catch (IOException e) { - System.err.println("Error writing to file: " + e.getMessage()); - } - } - - public static ModelEvalResult evaluateModel(File file) throws IOException, InterruptedException { - double totalTimeDimacs = 0; - File dimacsTargetFile = Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".dimacs").toFile(); - File opbTargetFile = Paths.get(WORKING_DIR, "tmp_files", file.getName() + ".opb").toFile(); - for (int i=0;i levels = new HashSet<>(); - levels.add(LanguageLevel.AGGREGATE_FUNCTION); - levels.add( LanguageLevel.STRING_CONSTRAINTS); - uvlModelFactory.convertLanguageLevel(featureModel, levels); - - try (BufferedWriter writer = new BufferedWriter(new FileWriter(targetFile))) { - if (tseitin) { - writer.append(featureModel.toOPBString()); - }else{ - featureModel.writeOPBStringToFile(modelFile, targetFile,writer); - } - writer.flush(); - } catch (IOException e) { - System.err.println("Error writing to file: " + e.getMessage()); - } - } - - public static void uvlToDimacsFeatureIDE(File modelFile, File targetFile) throws IOException { - UVLModelFactory uvlModelFactory = new UVLModelFactory(); - FeatureModel featureModel = loadUVLFeatureModelFromFile(modelFile.toString()); - Set levels = new HashSet<>(); - levels.add(LanguageLevel.BOOLEAN_LEVEL); - levels.add(LanguageLevel.TYPE_LEVEL); - uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); - - LibraryManager.registerLibrary(FMCoreLibrary.getInstance()); - FMFormatManager.getInstance().addExtension(new UVLFeatureModelFormat()); - - IFeatureModel fm = getFeatureIdeFMFromString(modelFile.toPath(), featureModel.toString()); - FileHandler.save(targetFile.toPath(), fm, new DIMACSFormat()); - } - - - public static IFeatureModel getFeatureIdeFMFromString(Path path, String content) throws IOException { - final FileHandler fileHandler = new FileHandler<>(path, null, null); - final UVLFeatureModelFormat format = new UVLFeatureModelFormat(); - try { - final IFeatureModel fm = FMFactoryManager.getInstance().getFactory(path, format).create(); - fileHandler.setObject(fm); - fileHandler.setFormat(format); - format.getInstance().read(fm, content, path); - - }catch (ExtensionManager.NoSuchExtensionException e) { - throw new IOException("Error while parsing UVL model"); - } - return fileHandler.getObject(); - } - - - - - - - - public static void uvlToDimacsZ3(String modelName) throws IOException { - uvlToSMT2(modelName + ".uvl", modelName + ".smt2"); - smt2ToDimacs(modelName + ".smt2", modelName + ".dimacs"); - } - - public static void smt2ToDimacs(String smt2Path, String dimacsPath) throws IOException { - long start = System.currentTimeMillis(); - ProcessBuilder processBuilder = new ProcessBuilder(); - processBuilder.command("python3", WORKING_DIR + "smt2ToDimacs.py", WORKING_DIR + smt2Path, WORKING_DIR + dimacsPath); - - try { - // Start the process - Process process = processBuilder.start(); - // Read the output from the process - BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); - String line; - while ((line = reader.readLine()) != null) { - System.out.println(line); - } - - // Wait for the process to complete and get the exit value - int exitCode = process.waitFor(); - if (exitCode != 0) { - throw new IOException("Z3 error"); - } - System.out.println("Process exited with code: " + exitCode); - } catch (IOException | InterruptedException e) { - e.printStackTrace(); - } - long finish = System.currentTimeMillis(); - System.out.println("z3_with_io: " + (finish - start)); - } - - public static void uvlToSMT2(String uvlPath, String dimacsPath) throws IOException { - long start = System.currentTimeMillis(); - UVLModelFactory uvlModelFactory = new UVLModelFactory(); - FeatureModel featureModel = loadUVLFeatureModelFromFile(WORKING_DIR + uvlPath); - Set levels = new HashSet<>(); - levels.add(LanguageLevel.BOOLEAN_LEVEL); - levels.add(LanguageLevel.TYPE_LEVEL); - uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); - - try (BufferedWriter writer = new BufferedWriter(new FileWriter(WORKING_DIR + "test.smt2"))) { - writer.append(featureModel.toSMT2string()); - writer.flush(); - } catch (IOException e) { - System.err.println("Error writing to file: " + e.getMessage()); - } - long finish = System.currentTimeMillis(); - System.out.println("smt_encoding_with_io: " + (finish - start)); - } - - private static FeatureModel loadUVLFeatureModelFromFile(String path) throws IOException { - Path filePath = Paths.get(path); - String content = new String(Files.readAllBytes(filePath)); - UVLModelFactory uvlModelFactory = new UVLModelFactory(); - FeatureModel featureModel = uvlModelFactory.parse(content); - return featureModel; - } -} diff --git a/src/main/java/de/vill/main/Example.java b/src/main/java/de/vill/main/Example.java index de7779d..c5ba734 100644 --- a/src/main/java/de/vill/main/Example.java +++ b/src/main/java/de/vill/main/Example.java @@ -1,83 +1,84 @@ package de.vill.main; -import de.vill.model.*; +import de.vill.config.Configuration; +import de.vill.model.Attribute; +import de.vill.model.Feature; +import de.vill.model.FeatureModel; +import de.vill.model.Group; import de.vill.model.constraint.Constraint; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.*; +import java.util.List; +import java.util.Map; public class Example { public static void main(String[] args) throws IOException { - FeatureModel featureModel = loadUVLFeatureModelFromFile("test.uvl"); - UVLModelFactory uvlModelFactory = new UVLModelFactory(); - //System.out.println(featureModel.toOPBString()); - - - - Set levels = new HashSet<>(); - levels.add(LanguageLevel.BOOLEAN_LEVEL); - levels.add( LanguageLevel.TYPE_LEVEL); - uvlModelFactory.convertExceptAcceptedLanguageLevel(featureModel, levels); - System.out.println(featureModel.composedModelToString()); - - - + //traverse all features depth first search + traverseAllFeatures(featureModel.getRootFeature()); + //get constraints of feature model from constraints section (no constraints from submodels or attribtues) + List ownConstraint = featureModel.getOwnConstraints(); + //traverse a constraint depth first search + if (ownConstraint.size() > 0) { + traverseConstraint(ownConstraint.get(0)); + } - /* - var c = featureModel.getConstraints().get(0); - HashMap subMap = new HashMap<>(); - int n = 1; - c.extractTseitinSubConstraints(subMap, n); - var map = transformSubFormulas(subMap); - List pbcList = transformImplicationMap(map); - System.out.println(pbcList.toString()); - - */ -//dimacsToOPB("/home/stefan/stefan-vill-master/tmp_eval/tmp5.dimacs"); - - } - - private static void dimacsToOPB(String path) throws IOException { - String[] lines = new String(Files.readAllBytes(Paths.get(path))).split("\n"); - List constraintList = new LinkedList<>(); - - for(String line : lines){ - if(!line.startsWith("c") && !line.startsWith("p")){ - PBConstraint PBConstraint = new PBConstraint(); - PBConstraint.literalList = new LinkedList<>(); - PBConstraint.k = 1; - for(String l : line.split(" ")){ - int v = Integer.parseInt(l); - if(v > 0){ - Literal literal = new Literal(); - literal.name = "x_" + v; - literal.factor = 1; - PBConstraint.literalList.add(literal); - }else if(v < 0){ - Literal literal = new Literal(); - literal.name = "x_" + (-1 * v); - literal.factor = -1; - PBConstraint.literalList.add(literal); - PBConstraint.k = PBConstraint.k -1; - } - } - constraintList.add(PBConstraint); + //get all constraints of feature model and submodels and attributes + List allConstraint = featureModel.getConstraints(); + + //get attribute from feature + String featureName = "featureName"; + String attributeName = "attributeName"; + Feature feature = featureModel.getFeatureMap().get(featureName); + if (feature != null) { + Attribute attribute = feature.getAttributes().get(attributeName); + if (attribute != null) { + Object value = attribute.getValue(); + System.out.println("Attribute " + attributeName + " of feature " + featureName + " is: " + value.toString()); + } else { + System.err.println("Attribute " + attributeName + " in feature " + featureName + " not found!"); } + } else { + System.err.println("Feature " + featureName + " not found!"); + } + + //make feature abstract + featureName = "featureName"; + feature = featureModel.getFeatureMap().get(featureName); + if (feature != null) { + feature.getAttributes().put("abstract", new Attribute<>("abstract", true, feature)); + } else { + System.err.println("Feature " + featureName + " not found!"); } - for(PBConstraint PBConstraint : constraintList){ - System.out.println(PBConstraint.toString() + ";"); + //change newline and tabulator symbol for printing + Configuration.setTabulatorSymbol(" "); + Configuration.setNewlineSymbol("\n"); + + //safe a single uvl model (this ignores any submodels) + String uvlModel = featureModel.toString(); + Path filePath = Paths.get("test_singleModel.uvl"); + Files.write(filePath, uvlModel.getBytes()); + + //safe a decomposed uvl model with all its submodels to individual files + Map modelList = featureModel.decomposedModelToString(); + for (Map.Entry uvlSubModel : modelList.entrySet()) { + //safe submodel in sub directory directory with namespace as name + Files.createDirectories(Paths.get("./subModels/")); + filePath = Paths.get("./subModels/" + uvlSubModel.getKey() + ".uvl"); + Files.write(filePath, uvlSubModel.getValue().getBytes()); } + //create a single uvl representation from a decomposed model and safe it to a single file + uvlModel = featureModel.composedModelToString(); + filePath = Paths.get("test_composedModel.uvl"); + Files.write(filePath, uvlModel.getBytes()); } /** diff --git a/src/main/java/de/vill/model/Feature.java b/src/main/java/de/vill/model/Feature.java index 10fce20..adba0c4 100644 --- a/src/main/java/de/vill/model/Feature.java +++ b/src/main/java/de/vill/model/Feature.java @@ -1,21 +1,13 @@ package de.vill.model; -import static de.vill.util.Util.addNecessaryQuotes; - -import java.io.BufferedWriter; -import java.util.Collection; -import java.util.HashMap; -import java.util.LinkedList; -import java.util.List; -import java.util.ListIterator; -import java.util.Map; -import java.util.Objects; - import de.vill.config.Configuration; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.OPBResult; import de.vill.util.Util; +import java.util.*; + +import static de.vill.util.Util.addNecessaryQuotes; + /** * This class represents a feature of any kind (normal, numeric, abstract, ...). */ @@ -374,103 +366,6 @@ public String toString() { public String getQuotedFeatureName(){ return "\"" + getFeatureName() + "\""; } - public void toOPBString(OPBResult result) { - List childGroups = getChildren(); - for (Group group : childGroups){ - switch (group.GROUPTYPE) { - case OPTIONAL: - result.opbString.append(group.getFeatures().size()); - result.opbString.append(" * "); - result.opbString.append(getQuotedFeatureName()); - for (Feature child : group.getFeatures()){ - result.opbString.append(" -1 * "); - result.opbString.append(child.getQuotedFeatureName()); - } - result.opbString.append(" >= 0;\n"); - result.numberConstraints++; - break; - case MANDATORY: - result.opbString.append(group.getFeatures().size()); - result.opbString.append(" * "); - result.opbString.append(getQuotedFeatureName()); - for (Feature child : group.getFeatures()){ - result.opbString.append(" -1 * "); - result.opbString.append(child.getQuotedFeatureName()); - } - result.opbString.append(" = 0;\n"); - result.numberConstraints += 2; - break; - case OR: - result.opbString.append("-1 * "); - result.opbString.append(getQuotedFeatureName()); - for (Feature child : group.getFeatures()){ - result.opbString.append(" + "); - result.opbString.append(child.getQuotedFeatureName()); - } - result.opbString.append(" >= 0;\n"); - result.numberConstraints++; - result.opbString.append(group.getFeatures().size()); - result.opbString.append(" * "); - result.opbString.append(getQuotedFeatureName()); - for (Feature child : group.getFeatures()){ - result.opbString.append(" -1 * "); - result.opbString.append(child.getQuotedFeatureName()); - } - result.opbString.append(" >= 0;\n"); - result.numberConstraints++; - break; - case ALTERNATIVE: - result.opbString.append(getQuotedFeatureName()); - for (Feature child : group.getFeatures()){ - result.opbString.append(" -1 * "); - result.opbString.append(child.getQuotedFeatureName()); - } - result.opbString.append(" = 0;\n"); - result.numberConstraints += 2; - break; - case GROUP_CARDINALITY: - result.opbString.append(group.getFeatures().size()); - result.opbString.append(" * "); - result.opbString.append(getQuotedFeatureName()); - for (Feature child : group.getFeatures()){ - result.opbString.append(" -1 * "); - result.opbString.append(child.getQuotedFeatureName()); - } - result.opbString.append(" >= 0;\n"); - result.numberConstraints++; - - - result.opbString.append("-"); - result.opbString.append(group.getCardinality().lower); - result.opbString.append(" * "); - result.opbString.append(getQuotedFeatureName()); - for (Feature child : group.getFeatures()){ - result.opbString.append(" +1 * "); - result.opbString.append(child.getQuotedFeatureName()); - } - result.opbString.append(" >= "); - result.opbString.append(0); - result.opbString.append(";\n"); - - - result.numberConstraints++; - result.opbString.append(getQuotedFeatureName()); - for (Feature child : group.getFeatures()){ - result.opbString.append(" +1 * "); - result.opbString.append(child.getQuotedFeatureName()); - } - result.opbString.append(" <= "); - result.opbString.append(group.getCardinality().upper + 1); - result.opbString.append(";\n"); - } - for (Feature child : group.getFeatures()){ - result.numberVariables++; - if(child.getChildren().size() > 0) { - child.toOPBString(result); - } - } - } - } /** * This method is necessary because the uvl string representation differs diff --git a/src/main/java/de/vill/model/FeatureModel.java b/src/main/java/de/vill/model/FeatureModel.java index 4f34bb1..b018fd2 100644 --- a/src/main/java/de/vill/model/FeatureModel.java +++ b/src/main/java/de/vill/model/FeatureModel.java @@ -1,47 +1,16 @@ package de.vill.model; -import java.io.*; -import java.nio.file.Path; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; - -import de.ovgu.featureide.fm.core.ExtensionManager; -import de.ovgu.featureide.fm.core.analysis.cnf.CNF; -import de.ovgu.featureide.fm.core.analysis.cnf.LiteralSet; -import de.ovgu.featureide.fm.core.analysis.cnf.Nodes; -import de.ovgu.featureide.fm.core.analysis.cnf.Variables; -import de.ovgu.featureide.fm.core.base.FeatureUtils; -import de.ovgu.featureide.fm.core.base.IFeatureModel; -import de.ovgu.featureide.fm.core.base.impl.FMFactoryManager; -import de.ovgu.featureide.fm.core.base.impl.FMFormatManager; -import de.ovgu.featureide.fm.core.editing.AdvancedNodeCreator; -import de.ovgu.featureide.fm.core.init.FMCoreLibrary; -import de.ovgu.featureide.fm.core.init.LibraryManager; -import de.ovgu.featureide.fm.core.io.manager.FileHandler; -import de.ovgu.featureide.fm.core.io.uvl.UVLFeatureModelFormat; import de.vill.config.Configuration; import de.vill.model.constraint.Constraint; import de.vill.model.constraint.LiteralConstraint; -import de.vill.model.constraint.NotConstraint; import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; import de.vill.model.expression.LiteralExpression; -import de.vill.model.pbc.OPBResult; -import de.vill.model.pbc.PBConstraint; -import de.vill.util.SubstitutionVariableIndex; import de.vill.util.Util; -import org.prop4j.And; -import org.prop4j.Literal; -import org.prop4j.Node; -import org.prop4j.Or; -import static de.vill.util.Util.*; +import java.util.*; + +import static de.vill.util.Util.addNecessaryQuotes; /** * This class represents a feature model and all its sub feature models if the @@ -278,126 +247,7 @@ public String toString() { return toString(false, ""); } - public StringBuilder toOPBString(){ - OPBResult result = new OPBResult(); - result.numberVariables++; - result.opbString.append(getRootFeature().getQuotedFeatureName()); - result.opbString.append(" >= 1;\n"); - result.numberConstraints++; - getRootFeature().toOPBString(result); - - List constraints = getConstraints(); - constraints.addAll(getFeatureConstraints()); - - for(Constraint constraint : constraints){ - //constraintDistributiveToOPB(constraint,result); - encodeConstraintTseitinStyle(constraint, result); - } - - SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); - result.numberVariables += substitutionVariableIndex.peekIndex(); - String header = "#variable= " + result.numberVariables + " #constraint= " + result.numberConstraints + "\n"; - result.opbString.insert(0,header); - - return result.opbString; - } - - public void writeOPBStringToFile(File fmFile, File opbFile, Writer writer) throws IOException { - OPBResult result = new OPBResult(); - result.numberVariables++; - result.opbString.append(getRootFeature().getQuotedFeatureName()); - result.opbString.append(" >= 1;\n"); - result.numberConstraints++; - getRootFeature().toOPBString(result); - - SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); - result.numberVariables += substitutionVariableIndex.peekIndex(); - String header = "#variable= " + result.numberVariables + " #constraint= " + result.numberConstraints + "\n"; - result.opbString.insert(0,header); - - List constraints = getConstraints(); - constraints.addAll(getFeatureConstraints()); - - for (Constraint constraint : constraints){ - var cnfConstraint = substituteExpressions(constraint, result).getNode().toCNF(); - List clauses = new LinkedList<>(); - if (cnfConstraint instanceof And) { - for(Node andChild : cnfConstraint.getChildren()){ - if (!(andChild instanceof Or)){ - clauses.add(new Or(andChild)); - }else{ - clauses.add(andChild); - } - } - }else{ - if (!(cnfConstraint instanceof Or)){ - clauses.add(new Or(cnfConstraint)); - }else{ - clauses.add(cnfConstraint); - } - } - for (Node clause : clauses){ - int negationCount = 0; - for (Literal literal : clause.getLiterals()) { - String variableName = (String)literal.var; - if (literal.positive){ - result.opbString.append(" +1 * "); - }else{ - result.opbString.append(" -1 * "); - negationCount++; - } - - result.opbString.append("\""); - result.opbString.append(variableName); - result.opbString.append("\""); - } - result.opbString.append(" >= "); - result.opbString.append(String.valueOf(1 - negationCount)); - result.opbString.append(";\n"); - } - } - - writer.append(result.opbString); - - } - - private IFeatureModel getFeatureIdeFMFromString(Path path, String content) throws IOException { - final FileHandler fileHandler = new FileHandler<>(path, null, null); - final UVLFeatureModelFormat format = new UVLFeatureModelFormat(); - try { - final IFeatureModel fm = FMFactoryManager.getInstance().getFactory(path, format).create(); - fileHandler.setObject(fm); - fileHandler.setFormat(format); - format.getInstance().read(fm, content, path); - - }catch (ExtensionManager.NoSuchExtensionException e) { - throw new IOException("Error while parsing UVL model"); - } - return fileHandler.getObject(); - } - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append("(set-logic QF_UF)\n"); - for (String name : this.getFeatureMap().keySet()) { - builder.append("(declare-const "); - builder.append(name); - builder.append(" Bool)\n"); - } - builder.append("(assert \n"); - builder.append(rootFeature.getFeatureName()); - builder.append(")\n"); - for (Group group : rootFeature.getChildren()){ - builder.append(group.toSMT2string()); - } - for (Constraint constraint : this.getConstraints()) { - builder.append("(assert \n"); - builder.append(constraint.toSMT2string()); - builder.append(")\n"); - } - builder.append("(apply tseitin-cnf)"); - return builder; - } /** * Returns a single uvl feature model composed out of all submodels. To avoid diff --git a/src/main/java/de/vill/model/Group.java b/src/main/java/de/vill/model/Group.java index b633735..00dc966 100644 --- a/src/main/java/de/vill/model/Group.java +++ b/src/main/java/de/vill/model/Group.java @@ -25,78 +25,6 @@ public enum GroupType { private Cardinality cardinality; private Feature parent; - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - - builder.append("(assert \n"); - switch (GROUPTYPE) { - case OR: - builder.append("(= \n"); - builder.append(parent.getFeatureName()); - builder.append("\n(or\n"); - for (Feature feature : features) { - builder.append(feature.getFeatureName()); - builder.append("\n"); - } - - builder.append("))\n"); - break; - case ALTERNATIVE: - builder.append("(and \n"); - builder.append("(= \n"); - builder.append(parent.getFeatureName()); - builder.append("\n(or\n"); - for (Feature feature : features) { - builder.append(feature.getFeatureName()); - builder.append("\n"); - } - - builder.append("))\n"); - for (int i=0;i "); - builder.append(feature.getFeatureName()); - builder.append(" "); - builder.append(parent.getFeatureName()); - builder.append(")\n"); - } - builder.append(")\n"); - break; - case MANDATORY: - builder.append("(and\n"); - for (Feature feature : features) { - builder.append("(= "); - builder.append(feature.getFeatureName()); - builder.append(" "); - builder.append(parent.getFeatureName()); - builder.append(")\n"); - } - builder.append(")\n"); - break; - } - builder.append(")\n"); - for (Feature feature : features) { - for (Group group : feature.getChildren()) { - builder.append(group.toSMT2string()); - } - } - return builder; - } - /** * The constructor of the group class. * diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index be4a0be..d3636ff 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -1,15 +1,11 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.PBCLiteralConstraint; -import de.vill.util.SubstitutionVariableIndex; -import org.prop4j.And; -import org.prop4j.Node; -import java.util.*; - -import static de.vill.util.Util.getMaxAndConstraint; -import static de.vill.util.Util.isJustAnd; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; public class AndConstraint extends Constraint { private Constraint left; @@ -36,13 +32,6 @@ public void setRight(Constraint right){ this.right = right; } - @Override - public Node getNode() { - var node = new And(); - node.setChildren(left.getNode(), right.getNode()); - return node; - } - @Override public String toString(boolean withSubmodels, String currentAlias) { return left.toString(withSubmodels, currentAlias) + @@ -96,36 +85,4 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } - - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - Constraint leftSub = getMaxAndConstraint(left, substitutionMapping); - Constraint rightSub = getMaxAndConstraint(right, substitutionMapping); - int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); - substitutionMapping.put(substitutionIndex, new AndConstraint(leftSub, rightSub)); - - return new PBCLiteralConstraint( - new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + substitutionIndex; - } - }) - ); - } - - @Override - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append("(and\n"); - builder.append(left.toSMT2string()); - builder.append("\n"); - if (right.toSMT2string().length() == 0) { - System.out.println("test"); - } - builder.append(right.toSMT2string()); - builder.append(")"); - return builder; - } - - ; } diff --git a/src/main/java/de/vill/model/constraint/Constraint.java b/src/main/java/de/vill/model/constraint/Constraint.java index 0cb308f..0aa3edc 100644 --- a/src/main/java/de/vill/model/constraint/Constraint.java +++ b/src/main/java/de/vill/model/constraint/Constraint.java @@ -1,14 +1,8 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCLiteralConstraint; -import org.prop4j.Node; -import java.util.HashMap; -import java.util.LinkedList; import java.util.List; -import java.util.Map; public abstract class Constraint { public int getLineNumber() { @@ -21,8 +15,6 @@ public void setLineNumber(int lineNumber) { private int lineNumber; - public abstract Node getNode(); - @Override public String toString() { return toString(true, ""); @@ -48,19 +40,5 @@ public int hashCode() { public abstract boolean equals(Object obj); public abstract List getReferences(); - - public abstract PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping); - - public StringBuilder toSMT2string(){ - return null; - } - - public List collectExpressions(){ - List expressions = new LinkedList<>(); - for (Constraint subConstraint : getConstraintSubParts()) { - expressions.addAll(subConstraint.collectExpressions()); - } - return expressions; - } } diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index f6f591e..23b7322 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -1,15 +1,11 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.PBCLiteralConstraint; -import de.vill.util.SubstitutionVariableIndex; -import org.prop4j.And; -import org.prop4j.Implies; -import org.prop4j.Node; -import java.util.*; - -import static de.vill.util.Util.isJustAnd; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; public class EquivalenceConstraint extends Constraint { private Constraint left; @@ -83,42 +79,4 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } - - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - - Constraint leftSub = left.extractTseitinSubConstraints(substitutionMapping); - Constraint rightSub = right.extractTseitinSubConstraints(substitutionMapping); - int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); - substitutionMapping.put(substitutionIndex, new EquivalenceConstraint(leftSub, rightSub)); - - return new PBCLiteralConstraint( - new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + substitutionIndex; - } - }) - ); - } - - @Override - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append("(=\n"); - builder.append(left.toSMT2string()); - builder.append("\n"); - builder.append(right.toSMT2string()); - builder.append(")"); - return builder; - } - - @Override - public Node getNode() { - var node = new And( - new Implies(left.getNode(), right.getNode()), - new Implies(right.getNode(), left.getNode()) - ); - return node; - } - } diff --git a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java index 75617a2..056dede 100644 --- a/src/main/java/de/vill/model/constraint/ExpressionConstraint.java +++ b/src/main/java/de/vill/model/constraint/ExpressionConstraint.java @@ -2,14 +2,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.expression.AggregateFunctionExpression; import de.vill.model.expression.Expression; -import de.vill.model.expression.LiteralExpression; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBCLiteralConstraint; -import de.vill.util.SubstitutionVariableIndex; -import org.prop4j.And; -import org.prop4j.Node; import java.util.*; @@ -127,30 +120,4 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } - - @Override - public List collectExpressions(){ - List expressions = new LinkedList<>(); - expressions.add(this); - return expressions; - } - - @Override - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); - substitutionMapping.put(substitutionIndex, this); - return new PBCLiteralConstraint( - new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + substitutionIndex; - } - }) - ); - } - - @Override - public Node getNode() { - return null; - } } diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index de2b740..a1cb8bb 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -1,15 +1,11 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.PBCLiteralConstraint; -import de.vill.util.SubstitutionVariableIndex; -import org.prop4j.And; -import org.prop4j.Implies; -import org.prop4j.Node; -import java.util.*; - -import static de.vill.util.Util.isJustAnd; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; public class ImplicationConstraint extends Constraint { private Constraint left; @@ -84,36 +80,4 @@ public List getReferences() { return references; } - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - Constraint leftSub = left.extractTseitinSubConstraints(substitutionMapping); - Constraint rightSub = right.extractTseitinSubConstraints(substitutionMapping); - int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); - substitutionMapping.put(substitutionIndex, new ImplicationConstraint(leftSub, rightSub)); - - return new PBCLiteralConstraint( - new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + substitutionIndex; - } - }) - ); - } - - @Override - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append("(=>\n"); - builder.append(left.toSMT2string()); - builder.append("\n"); - builder.append(right.toSMT2string()); - builder.append(")"); - return builder; - } - - @Override - public Node getNode() { - var node = new Implies(left.getNode(), right.getNode()); - return node; - } } diff --git a/src/main/java/de/vill/model/constraint/LiteralConstraint.java b/src/main/java/de/vill/model/constraint/LiteralConstraint.java index a8df29c..12ab542 100644 --- a/src/main/java/de/vill/model/constraint/LiteralConstraint.java +++ b/src/main/java/de/vill/model/constraint/LiteralConstraint.java @@ -1,16 +1,9 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.PBCLiteralConstraint; -import de.vill.util.SubstitutionVariableIndex; import de.vill.util.Util; -import org.prop4j.And; -import org.prop4j.Literal; -import org.prop4j.Node; -import java.util.HashMap; import java.util.List; -import java.util.Map; import java.util.Objects; public class LiteralConstraint extends Constraint { @@ -68,22 +61,4 @@ public boolean equals(Object obj) { public List getReferences() { return List.of(reference); } - - @Override - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append(reference.getIdentifier()); - return builder; - } - - @Override - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - return new PBCLiteralConstraint(this); - } - - @Override - public Node getNode() { - var node = new Literal(reference.getIdentifier(), true); - return node; - } } diff --git a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java index ed44a4a..63fa6a6 100644 --- a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java +++ b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java @@ -1,10 +1,10 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.PBCLiteralConstraint; -import org.prop4j.Node; -import java.util.*; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; public class MultiOrConstraint extends Constraint{ @@ -14,11 +14,6 @@ public MultiOrConstraint() { sub_parts = new LinkedList<>(); } - @Override - public Node getNode() { - return null; - } - @Override public String toString(boolean withSubmodels, String currentAlias) { StringBuilder result = new StringBuilder(); @@ -99,24 +94,4 @@ public List getReferences() { } return references; } - - @Override - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - //TODO - return null; - } - - @Override - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append("(or\n"); - for (Constraint constraint : sub_parts) { - builder.append(constraint.toSMT2string()); - builder.append("\n"); - } - builder.append(")"); - return builder; - } - - } diff --git a/src/main/java/de/vill/model/constraint/NotConstraint.java b/src/main/java/de/vill/model/constraint/NotConstraint.java index f4c3879..6490f0e 100644 --- a/src/main/java/de/vill/model/constraint/NotConstraint.java +++ b/src/main/java/de/vill/model/constraint/NotConstraint.java @@ -1,13 +1,10 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.PBCLiteralConstraint; -import org.prop4j.And; -import org.prop4j.Node; -import org.prop4j.Not; -import org.prop4j.Or; -import java.util.*; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; public class NotConstraint extends Constraint { private Constraint content; @@ -73,39 +70,6 @@ public List getReferences() { return content.getReferences(); } - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - PBCLiteralConstraint subContent = content.extractTseitinSubConstraints(substitutionMapping); - //int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); - //substitutionMapping.put(substitutionIndex, new NotConstraint(subContent)); -/* - PBCLiteralConstraint result = new PBCLiteralConstraint( - new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + substitutionIndex; - } - }) - ); - result.toggleSign(); - */ - subContent.toggleSign(); - return subContent; - } - - @Override - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append("(not\n"); - builder.append(content.toSMT2string()); - builder.append("\n"); - builder.append(")"); - return builder; - } - @Override - public Node getNode() { - var node = new Not(content.getNode()); - return node; - } } diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index 559fe16..bcfd655 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -1,15 +1,11 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.PBCLiteralConstraint; -import de.vill.util.SubstitutionVariableIndex; -import org.prop4j.And; -import org.prop4j.Node; -import org.prop4j.Or; -import java.util.*; - -import static de.vill.util.Util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; public class OrConstraint extends Constraint { @@ -90,39 +86,4 @@ public List getReferences() { references.addAll(right.getReferences()); return references; } - - @Override - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - Constraint leftSub = getMaxOrConstraint(left, substitutionMapping); - Constraint rightSub = getMaxOrConstraint(right, substitutionMapping); - int substitutionIndex = SubstitutionVariableIndex.getInstance().getIndex(); - substitutionMapping.put(substitutionIndex, new OrConstraint(leftSub, rightSub)); - - return new PBCLiteralConstraint( - new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return "x_" + substitutionIndex; - } - }) - ); - } - - @Override - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append("(or\n"); - builder.append(left.toSMT2string()); - builder.append("\n"); - builder.append(right.toSMT2string()); - builder.append(")"); - return builder; - } - - @Override - public Node getNode() { - var node = new Or(); - node.setChildren(left.getNode(), right.getNode()); - return node; - } } diff --git a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java index d62e0c0..52b03fe 100644 --- a/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java +++ b/src/main/java/de/vill/model/constraint/ParenthesisConstraint.java @@ -1,11 +1,10 @@ package de.vill.model.constraint; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.PBCLiteralConstraint; -import org.prop4j.And; -import org.prop4j.Node; -import java.util.*; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; public class ParenthesisConstraint extends Constraint { private Constraint content; @@ -63,20 +62,4 @@ public boolean equals(Object obj) { public List getReferences() { return content.getReferences(); } - - public PBCLiteralConstraint extractTseitinSubConstraints(Map substitutionMapping) { - return content.extractTseitinSubConstraints(substitutionMapping); - }; - - @Override - public StringBuilder toSMT2string() { - StringBuilder builder = new StringBuilder(); - builder.append(content.toSMT2string()); - return builder; - } - - @Override - public Node getNode() { - return content.getNode(); - } } diff --git a/src/main/java/de/vill/model/expression/AddExpression.java b/src/main/java/de/vill/model/expression/AddExpression.java index 3c45d56..709088e 100644 --- a/src/main/java/de/vill/model/expression/AddExpression.java +++ b/src/main/java/de/vill/model/expression/AddExpression.java @@ -2,8 +2,6 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.*; @@ -86,15 +84,6 @@ public List getReferences() { return references; } - @Override - public List getAsSum(List additionalSubstitution) { - List result = new LinkedList<>(); - result.addAll(left.getAsSum(additionalSubstitution)); - List rightSum = right.getAsSum(additionalSubstitution); - result.addAll(rightSum); - return result; - } - @Override public Expression clone(){ return new AddExpression(left.clone(), right.clone()); diff --git a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java index 2747508..0cb3202 100644 --- a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java @@ -1,15 +1,16 @@ package de.vill.model.expression; -import static de.vill.util.Util.addNecessaryQuotes; - import de.vill.model.Feature; import de.vill.model.GlobalAttribute; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; -import java.util.*; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.Set; + +import static de.vill.util.Util.addNecessaryQuotes; public class AggregateFunctionExpression extends Expression { @@ -114,11 +115,6 @@ public List getReferences() { return List.of(attribute); } - @Override - public List getAsSum(List additionalSubstitution) { - throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); - } - @Override public Expression clone(){ return new AggregateFunctionExpression(attribute, rootFeature); diff --git a/src/main/java/de/vill/model/expression/DivExpression.java b/src/main/java/de/vill/model/expression/DivExpression.java index ef7ea9b..7c6e2c8 100644 --- a/src/main/java/de/vill/model/expression/DivExpression.java +++ b/src/main/java/de/vill/model/expression/DivExpression.java @@ -1,17 +1,11 @@ package de.vill.model.expression; -import com.google.common.collect.Sets; import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; -import de.vill.util.SubstitutionVariableIndex; import java.util.*; -import static de.vill.util.Util.substitutionConstraint; - public class DivExpression extends BinaryExpression { private Expression left; private Expression right; @@ -90,71 +84,6 @@ public List getReferences() { return references; } - @Override - public List getAsSum(List additionalSubstitution) { - List result = new LinkedList<>(); - List numeratorSum = getLeft().getAsSum(additionalSubstitution); - List denominatorSum = getRight().getAsSum(additionalSubstitution); - SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); - for (Literal l : numeratorSum) { - Set> literalCombinations = getLiteralCombinations(new HashSet(denominatorSum)); - for (Set combination : literalCombinations) { - Literal newSummand = new Literal(); - newSummand.factor = l.factor; - double denominatorFactorSum = 0.0; - for (Literal denominatorLiteral : combination) { - denominatorFactorSum += denominatorLiteral.factor; - } - newSummand.factor /= denominatorFactorSum; - var subIndex = substitutionVariableIndex.getIndex(); - newSummand.name = "x_" + subIndex; - result.add(newSummand); - PBConstraint denominatorConstraint = featureCombinationToPBConstraint(combination, denominatorSum); - if (l.name != null) { - denominatorConstraint.literalList.add(new Literal(1, l.name, l.sign)); - denominatorConstraint.k += 1; - } - - additionalSubstitution.addAll(substitutionConstraint(denominatorConstraint, newSummand.name)); - } - } - return result; - } - - private Set> getLiteralCombinations(Set literals) { - Set> literalCombinations = new HashSet<>(); - for (int i = 1; i <= literals.size(); i++) { - literalCombinations.addAll(Sets.combinations(literals, i)); - } - return literalCombinations; - } - - private PBConstraint featureCombinationToPBConstraint(Set takenLiterals, List allLiterals) { - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = allLiterals.size(); - for (Literal literal : allLiterals) { - if (literal.name != null){ - if (takenLiterals.contains(literal)) { - //literal positive in result - Literal newLiteral = new Literal(); - newLiteral.name = literal.name; - newLiteral.factor = 1; - newLiteral.sign = literal.sign; - pbConstraint.literalList.add(newLiteral); - }else { - //literal negative in result - Literal negatedLiteral = new Literal(); - negatedLiteral.name = literal.name; - negatedLiteral.factor = 1; - negatedLiteral.sign = !literal.sign; - pbConstraint.literalList.add(negatedLiteral); - } - } - } - return pbConstraint; - } - @Override public Expression clone(){ return new DivExpression(left.clone(), right.clone()); diff --git a/src/main/java/de/vill/model/expression/Expression.java b/src/main/java/de/vill/model/expression/Expression.java index d2d6a2d..510f19c 100644 --- a/src/main/java/de/vill/model/expression/Expression.java +++ b/src/main/java/de/vill/model/expression/Expression.java @@ -2,12 +2,8 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.constraint.Constraint; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import java.util.List; -import java.util.Map; import java.util.Set; public abstract class Expression { @@ -50,6 +46,4 @@ public int hashCode() { public abstract Expression clone(); public abstract List getReferences(); - - public abstract List getAsSum(List additionalSubstitution); } diff --git a/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java index 7d7debc..a50ebbd 100644 --- a/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/LengthAggregateFunctionExpression.java @@ -2,8 +2,6 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import de.vill.util.Util; @@ -89,11 +87,6 @@ public List getReferences() { return List.of(); } - @Override - public List getAsSum(List additionalSubstitution) { - throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); - } - @Override public Expression clone(){ return new LengthAggregateFunctionExpression(getReference()); diff --git a/src/main/java/de/vill/model/expression/LiteralExpression.java b/src/main/java/de/vill/model/expression/LiteralExpression.java index 7f2ce56..835f036 100644 --- a/src/main/java/de/vill/model/expression/LiteralExpression.java +++ b/src/main/java/de/vill/model/expression/LiteralExpression.java @@ -4,12 +4,13 @@ import de.vill.model.Feature; import de.vill.model.FeatureType; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import de.vill.util.Util; -import java.util.*; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.Set; public class LiteralExpression extends Expression { private VariableReference content; @@ -124,17 +125,6 @@ public List getReferences() { return List.of(content); } - @Override - public List getAsSum(List additionalSubstitution) { - Literal l = new Literal(); - var attribute = (Attribute)getContent(); - l.name = attribute.getFeature().getFeatureName(); - l.factor = attribute.getValue() instanceof Long ? ((Long) attribute.getValue()).doubleValue() : (double) attribute.getValue(); - List result = new LinkedList<>(); - result.add(l); - return result; - } - @Override public Expression clone(){ return new LiteralExpression(content); diff --git a/src/main/java/de/vill/model/expression/MulExpression.java b/src/main/java/de/vill/model/expression/MulExpression.java index 6953228..f33359e 100644 --- a/src/main/java/de/vill/model/expression/MulExpression.java +++ b/src/main/java/de/vill/model/expression/MulExpression.java @@ -2,10 +2,7 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; -import de.vill.util.SubstitutionVariableIndex; import java.util.*; @@ -96,52 +93,6 @@ public List getReferences() { return references; } - @Override - public List getAsSum(List additionalSubstitution) { - var leftSum = left.getAsSum(additionalSubstitution); - var rightSum = right.getAsSum(additionalSubstitution); - List result = new LinkedList<>(); - SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); - for (int i=0;i getSubstitutionConstraints(String a, String b, String c){ - List result = new LinkedList<>(); - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.literalList = new LinkedList<>(); - PBConstraint1.k = 0; - PBConstraint1.literalList.add(new Literal(1, a, true)); - PBConstraint1.literalList.add(new Literal(1, b, true)); - PBConstraint1.literalList.add(new Literal(-2, c, true)); - result.add(PBConstraint1); - PBConstraint PBConstraint2 = new PBConstraint(); - PBConstraint2.literalList = new LinkedList<>(); - PBConstraint2.k = -1; - PBConstraint2.literalList.add(new Literal(-1, a, true)); - PBConstraint2.literalList.add(new Literal(-1, b, true)); - PBConstraint2.literalList.add(new Literal(2, c, true)); - result.add(PBConstraint2); - return result; - } - @Override public String getReturnType() { return Constants.NUMBER; diff --git a/src/main/java/de/vill/model/expression/NumberExpression.java b/src/main/java/de/vill/model/expression/NumberExpression.java index 8be8158..33799f0 100644 --- a/src/main/java/de/vill/model/expression/NumberExpression.java +++ b/src/main/java/de/vill/model/expression/NumberExpression.java @@ -2,8 +2,6 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.*; @@ -84,13 +82,6 @@ public List getReferences() { return new ArrayList<>(); } - @Override - public List getAsSum(List additionalSubstitution) { - List result = new LinkedList<>(); - result.add(new Literal(number, null, true)); - return result; - } - @Override public String getReturnType() { return Constants.NUMBER; diff --git a/src/main/java/de/vill/model/expression/ParenthesisExpression.java b/src/main/java/de/vill/model/expression/ParenthesisExpression.java index ef89972..2cc6fa3 100644 --- a/src/main/java/de/vill/model/expression/ParenthesisExpression.java +++ b/src/main/java/de/vill/model/expression/ParenthesisExpression.java @@ -2,8 +2,6 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import java.util.Collections; import java.util.List; @@ -75,11 +73,6 @@ public List getReferences() { return List.of(); } - @Override - public List getAsSum(List additionalSubstitution) { - return getContent().getAsSum(additionalSubstitution); - } - @Override public String getReturnType() { return content.getReturnType(); diff --git a/src/main/java/de/vill/model/expression/StringExpression.java b/src/main/java/de/vill/model/expression/StringExpression.java index 332cc16..2ffcad2 100644 --- a/src/main/java/de/vill/model/expression/StringExpression.java +++ b/src/main/java/de/vill/model/expression/StringExpression.java @@ -2,8 +2,6 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.*; @@ -81,11 +79,6 @@ public List getReferences() { return new ArrayList<>(); } - @Override - public List getAsSum(List additionalSubstitution) { - throw new UnsupportedOperationException("All AggregateFunctions must be removed before method is called."); - } - @Override public String getReturnType() { return Constants.STRING; diff --git a/src/main/java/de/vill/model/expression/SubExpression.java b/src/main/java/de/vill/model/expression/SubExpression.java index 9c7773d..53b81f4 100644 --- a/src/main/java/de/vill/model/expression/SubExpression.java +++ b/src/main/java/de/vill/model/expression/SubExpression.java @@ -2,8 +2,6 @@ import de.vill.model.Feature; import de.vill.model.building.VariableReference; -import de.vill.model.pbc.Literal; -import de.vill.model.pbc.PBConstraint; import de.vill.util.Constants; import java.util.*; @@ -78,16 +76,6 @@ public List getReferences() { return result; } - public List getAsSum(List additionalSubstitution) { - var result = left.getAsSum(additionalSubstitution); - var rightResult = right.getAsSum(additionalSubstitution); - for (Literal l : rightResult){ - l.factor *= -1; - } - result.addAll(rightResult); - return result; - } - @Override public String getReturnType() { return Constants.NUMBER; diff --git a/src/main/java/de/vill/model/pbc/Literal.java b/src/main/java/de/vill/model/pbc/Literal.java deleted file mode 100644 index ba5e94f..0000000 --- a/src/main/java/de/vill/model/pbc/Literal.java +++ /dev/null @@ -1,36 +0,0 @@ -package de.vill.model.pbc; - -public class Literal implements Cloneable{ - public String name; - public double factor; - public boolean sign = true; - public Literal(){} - public Literal(double factor, String name, boolean sign) { - this.name = name; - this.factor = factor; - this.sign = sign; - } - - @Override - public Literal clone() { - Literal literal = null; - try { - literal = (Literal) super.clone(); - } catch (CloneNotSupportedException e) { - literal = new Literal(); - literal.name = this.name; - literal.factor = this.factor; - literal.sign = this.sign; - } - return literal; - } - - @Override - public String toString() { - String signString = "+"; - if (factor < 0) { - signString = ""; - } - return " " + signString + factor + " * " + (sign ? name : "neg(" + name + ")"); - } -} diff --git a/src/main/java/de/vill/model/pbc/OPBResult.java b/src/main/java/de/vill/model/pbc/OPBResult.java deleted file mode 100644 index b2ac179..0000000 --- a/src/main/java/de/vill/model/pbc/OPBResult.java +++ /dev/null @@ -1,7 +0,0 @@ -package de.vill.model.pbc; - -public class OPBResult { - public long numberVariables = 0; - public long numberConstraints = 0; - public StringBuilder opbString = new StringBuilder(); -} diff --git a/src/main/java/de/vill/model/pbc/PBCLiteralConstraint.java b/src/main/java/de/vill/model/pbc/PBCLiteralConstraint.java deleted file mode 100644 index 0c17402..0000000 --- a/src/main/java/de/vill/model/pbc/PBCLiteralConstraint.java +++ /dev/null @@ -1,19 +0,0 @@ -package de.vill.model.pbc; - -import de.vill.model.building.VariableReference; -import de.vill.model.constraint.LiteralConstraint; - -public class PBCLiteralConstraint extends LiteralConstraint { - public boolean sign = true; - public PBCLiteralConstraint(VariableReference reference) { - super(reference); - } - - public PBCLiteralConstraint(LiteralConstraint literalConstraint){ - super(literalConstraint.getReference()); - } - - public void toggleSign(){ - sign = !sign; - } -} diff --git a/src/main/java/de/vill/model/pbc/PBConstraint.java b/src/main/java/de/vill/model/pbc/PBConstraint.java deleted file mode 100644 index 226846d..0000000 --- a/src/main/java/de/vill/model/pbc/PBConstraint.java +++ /dev/null @@ -1,180 +0,0 @@ -package de.vill.model.pbc; - -import java.text.DecimalFormat; -import java.util.LinkedList; -import java.util.List; - -public class PBConstraint implements Cloneable{ - public List literalList; - public double k; - public PBConstraintType type; - - public PBConstraint() { - type = PBConstraintType.GEQ; - literalList = new LinkedList<>(); - } - - public PBConstraint negatedConstraint() { - PBConstraint newConstraint = (PBConstraint)clone(); - switch (type) { - case GEQ: - newConstraint.type = PBConstraintType.LE; - break; - case GE: - newConstraint.type = PBConstraintType.LEQ; - break; - case LEQ: - newConstraint.type = PBConstraintType.GE; - break; - case LE: - newConstraint.type = PBConstraintType.GEQ; - break; - case EQ: - newConstraint.type = PBConstraintType.NOTEQ; - break; - case NOTEQ: - newConstraint.type = PBConstraintType.EQ; - break; - } - return newConstraint; - } - - public List orWithLiteral(String literalName, boolean sign) { - PBConstraint newConstraint = (PBConstraint)clone(); - double f = this.k; - switch (type) { - case GEQ: - for (Literal l : this.literalList){ - f += Math.abs(l.factor); - } - break; - case GE: - for (Literal l : this.literalList){ - f += Math.abs(l.factor); - } - f++; - break; - case LEQ: - for (Literal l : this.literalList){ - f -= Math.abs(l.factor); - } - break; - case LE: - for (Literal l : this.literalList){ - f -= Math.abs(l.factor); - } - f--; - break; - case EQ: - PBConstraint c1 = clone(); - PBConstraint c2 = clone(); - c1.type = PBConstraintType.LEQ; - c2.type = PBConstraintType.GEQ; - List resultList = new LinkedList<>(); - resultList.addAll(c1.orWithLiteral(literalName, sign)); - resultList.addAll(c2.orWithLiteral(literalName, sign)); - return resultList; - case NOTEQ: - for (Literal l : this.literalList){ - f += Math.abs(l.factor); - } - f++; - break; - } - if (sign) { - newConstraint.literalList.add(new Literal(f, literalName, true)); - } else { - newConstraint.k -= f; - newConstraint.literalList.add(new Literal(-f, literalName, true)); - } - - List resultList = new LinkedList<>(); - resultList.add(newConstraint); - return resultList; - } - - public void toOPBString(OPBResult result) { - DecimalFormat df = new DecimalFormat("#.####"); - for (Literal l : literalList) { - if (!l.sign){ - k -= l.factor; - l.factor *= -1; - l.sign = !l.sign; - } - l.factor = Double.parseDouble(df.format(l.factor)); - } - k = Double.parseDouble(df.format(k)); - result.numberConstraints++; - int maxDecimalPlaces = getMaxDecimalPlaces(); - for(Literal l : literalList){ - if(l.factor < 0){ - result.opbString.append(" "); - result.opbString.append((long) (l.factor * Math.pow(10,maxDecimalPlaces))); - }else{ - result.opbString.append(" +"); - result.opbString.append((long) (l.factor * Math.pow(10,maxDecimalPlaces))); - } - result.opbString.append(" "); - result.opbString.append("\"" + l.name + "\""); - } - result.opbString.append(" "); - result.opbString.append(type); - result.opbString.append(" "); - result.opbString.append((long) (k * Math.pow(10,maxDecimalPlaces))); - result.opbString.append(";\n"); - } - - private int getMaxDecimalPlaces() { - int maxDecimalPlaces = 0; - int kDecimalPlaces = countDecimalPlaces(k); - if (kDecimalPlaces > maxDecimalPlaces) { - maxDecimalPlaces = kDecimalPlaces; - } - for (Literal l : literalList) { - int lDecimalPlaces = countDecimalPlaces(l.factor); - if (lDecimalPlaces > maxDecimalPlaces) { - maxDecimalPlaces = lDecimalPlaces; - } - } - return maxDecimalPlaces; - } - - private int countDecimalPlaces(double value) { - String text = String.valueOf(value); - - if (text.contains(".")) { - return text.length() - text.indexOf('.') - 1; - } else { - return 0; - } - } - - @Override - public PBConstraint clone() { - PBConstraint pbConstraint = null; - try { - pbConstraint = (PBConstraint) super.clone(); - } catch (CloneNotSupportedException e) { - pbConstraint = new PBConstraint(); - pbConstraint.type = this.type; - pbConstraint.k = this.k; - } - pbConstraint.literalList = new LinkedList<>(); - for (Literal l : this.literalList) { - pbConstraint.literalList.add(l.clone()); - } - - return pbConstraint; - } - - @Override - public String toString() { - String result = ""; - for (Literal literal : literalList) { - result += literal.toString(); - } - result += " " + type + k; - return result; - } -} - diff --git a/src/main/java/de/vill/model/pbc/PBConstraintType.java b/src/main/java/de/vill/model/pbc/PBConstraintType.java deleted file mode 100644 index 2cb3c76..0000000 --- a/src/main/java/de/vill/model/pbc/PBConstraintType.java +++ /dev/null @@ -1,25 +0,0 @@ -package de.vill.model.pbc; - -public enum PBConstraintType { - GEQ(">="), - GE(">"), - LEQ("<="), - LE("<"), - EQ("="), - NOTEQ("!="); - - private String value; - - PBConstraintType(String value) { - this.value = value; - } - - public String getValue() { - return value; - } - - @Override - public String toString() { - return this.value; - } -} diff --git a/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java b/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java deleted file mode 100644 index 55beabc..0000000 --- a/src/main/java/de/vill/util/ConvertFeatureCardinalityForOPB.java +++ /dev/null @@ -1,266 +0,0 @@ -package de.vill.util; - -import de.vill.conversion.IConversionStrategy; -import de.vill.model.*; -import de.vill.model.constraint.*; -import de.vill.model.expression.Expression; -import de.vill.model.expression.LiteralExpression; - -import javax.smartcardio.Card; -import java.util.*; - -public class ConvertFeatureCardinalityForOPB { - - public void convertFeatureModel(FeatureModel featureModel) { - traverseFeatures(featureModel.getRootFeature(), featureModel); - } - - private void traverseFeatures(Feature feature, FeatureModel featureModel) { - if (!feature.isSubmodelRoot()) { - if (feature.getCardinality() != null) { - List subTreeFeatures = new LinkedList<>(); - for (Group group : feature.getChildren()) { - subTreeFeatures.addAll(getFeatureFromSubTree(group)); - } - List constraintsToClone = getConstraintsOnSubTree(featureModel, subTreeFeatures); - - removeFeatureCardinality(feature, featureModel, constraintsToClone); - } - for (Group children : feature.getChildren()) { - for (Feature subFeature : children.getFeatures()) { - traverseFeatures(subFeature, featureModel); - } - } - } - } - - private void removeFeatureCardinality(Feature feature, FeatureModel featureModel, List constraintsToClone) { - int min = feature.getCardinality().lower; - int max = feature.getCardinality().upper; - Group newChildren = new Group(Group.GroupType.GROUP_CARDINALITY); - newChildren.setCardinality(new Cardinality(min == 0 ? min + 1 : min, min == 0 ? max + 1 : max)); - - feature.setCardinality(null); - - for (int i = min; i <= max; i++) { - Feature subTreeClone = feature.clone(); - addPrefixToNamesRecursively(subTreeClone, "_" + i, featureModel); - newChildren.getFeatures().add(subTreeClone); - subTreeClone.setParentGroup(newChildren); - - if (i == 0) { - subTreeClone.getChildren().clear(); - }else{ - Map constraintReplacementMap = new HashMap<>(); - createFeatureReplacementMap(feature, subTreeClone, constraintReplacementMap); - constraintReplacementMap.remove(feature.getFeatureName()); - for (Constraint constraint : constraintsToClone) { - Constraint newConstraint = constraint.clone(); - adaptConstraint(subTreeClone, newConstraint, constraintReplacementMap); - LiteralConstraint subTreeRootConstraint = new LiteralConstraint(subTreeClone); - newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newConstraint)); - featureModel.getOwnConstraints().add(newConstraint); - - } - } - - } - for (int i = min; i < max; i++) { - Constraint lastTakenInGroupCardinality = new LiteralConstraint(newChildren.getFeatures().get(i - min)); - List notToTakeInGroupCarrdinality = new LinkedList<>(); - for (int k=i+1;k<=max;k++){ - notToTakeInGroupCarrdinality.add(new LiteralConstraint(newChildren.getFeatures().get(k - min))); - } - Constraint groupCardinalityOrderConstraint = new ImplicationConstraint(new NotConstraint(lastTakenInGroupCardinality), new NotConstraint(createDisjunction(notToTakeInGroupCarrdinality))); - featureModel.getOwnConstraints().add(groupCardinalityOrderConstraint); - } - - /* - new constraint with all cloned features ored - Set allFeatureNamesInSubTree = new HashSet<>(); - getAllSubFeatureNamesRecursively(feature, allFeatureNamesInSubTree); - for (Constraint constraint : constraintsToClone) { - Constraint newConstraint = constraint.clone(); - orAdaptedConstraint(newConstraint, allFeatureNamesInSubTree, min, max, featureModel); - featureModel.getOwnConstraints().add(newConstraint); - } - - */ - - feature.getChildren().removeAll(feature.getChildren()); - feature.getChildren().add(newChildren); - newChildren.setParentFeature(feature); - } - - private void orAdaptedConstraint(Constraint constraint, Set featuresToReplace, int min, int max, FeatureModel featureModel) { - for (Constraint subPart : constraint.getConstraintSubParts()) { - if (subPart instanceof LiteralConstraint) { - String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); - if (featuresToReplace.contains(toReplace)){ - Feature f = featureModel.getFeatureMap().get(toReplace + "_" + min); - Constraint newOr = new LiteralConstraint(f); - for (int i = min + 1; i <= max; i++) { - newOr = new OrConstraint(newOr, new LiteralConstraint(featureModel.getFeatureMap().get(toReplace + "_" + i))); - } - constraint.replaceConstraintSubPart(subPart, new ParenthesisConstraint(newOr)); - } - }else { - orAdaptedConstraint(subPart, featuresToReplace, min, max, featureModel); - } - } - } - - private void getAllSubFeatureNamesRecursively(Feature feature, Set names) { - names.add(feature.getFeatureName()); - for (Group child : feature.getChildren()) { - for(Feature childFeature : child.getFeatures()){ - getAllSubFeatureNamesRecursively(childFeature, names); - } - } - } - - private Constraint createDisjunction(List literals) { - if (literals.size() == 1) { - return literals.get(0); - } - LiteralConstraint literalConstraint = literals.get(0); - literals.remove(0); - return new OrConstraint(literalConstraint, createDisjunction(literals)); - } - - private void addPrefixToNamesRecursively(Feature feature, String prefix, FeatureModel featureModel) { - feature.setFeatureName(feature.getFeatureName() + prefix); - featureModel.getFeatureMap().put(feature.getFeatureName(), feature); - if (!feature.isSubmodelRoot()) { - for (Group group : feature.getChildren()) { - for (Feature subFeature : group.getFeatures()) { - addPrefixToNamesRecursively(subFeature, prefix, featureModel); - } - } - } - } - - private List getConstraintsOnSubTree(FeatureModel featureModel, List subTreeFeatures) { - List constraints = new LinkedList<>(); - for (Constraint constraint : featureModel.getConstraints()) { - if (constraintContains(constraint, subTreeFeatures)) { - constraints.add(constraint); - featureModel.getOwnConstraints().remove(constraint); - } - } - return constraints; - } - - private List getFeatureFromSubTree(Group group) { - List features = new LinkedList<>(); - features.addAll(group.getFeatures()); - for (Feature subFeatures : group.getFeatures()) { - if (!subFeatures.isSubmodelRoot()) { - for (Group subGroup : subFeatures.getChildren()) { - features.addAll(getFeatureFromSubTree(subGroup)); - } - } - } - return features; - } - - private boolean constraintContains(Constraint constraint, List subTreeFeatures) { - if (constraint instanceof LiteralConstraint && ((LiteralConstraint) constraint).getReference() instanceof Feature) { - Feature feature = (Feature) ((LiteralConstraint) constraint).getReference(); - if (subTreeFeatures.contains(feature)) { - return true; - } - }else if (constraint instanceof ExpressionConstraint) { - Expression left = ((ExpressionConstraint) constraint).getLeft(); - Expression right = ((ExpressionConstraint) constraint).getRight(); - return expressionContains(left,subTreeFeatures) || expressionContains(right,subTreeFeatures); - } - - List subParts = constraint.getConstraintSubParts(); - for (Constraint subPart : subParts) { - if (subPart instanceof LiteralConstraint && ((LiteralConstraint) subPart).getReference() instanceof Feature) { - Feature feature = (Feature) ((LiteralConstraint) subPart).getReference(); - if (subTreeFeatures.contains(feature)) { - return true; - } - } else { - if (constraintContains(subPart, subTreeFeatures)) { - return true; - } - - } - } - return false; - } - - private boolean expressionContains(Expression expression, List subTreeFeatures) { - if (expression instanceof LiteralExpression) { - Feature feature = (Feature) ((Attribute) ((LiteralExpression) expression).getContent()).getFeature(); - if (subTreeFeatures.contains(feature)) { - return true; - } - } - - for (Expression subExpression : expression.getExpressionSubParts()) { - if (expression instanceof LiteralExpression) { - Feature feature = (Feature) ((LiteralExpression) expression).getContent(); - if (subTreeFeatures.contains(feature)) { - return true; - } - }else if(expressionContains(subExpression, subTreeFeatures)){ - return true; - } - } - return false; - } - - - private void createFeatureReplacementMap(Feature oldSubTree, Feature newSubTree, Map featureFeatureMap) { - featureFeatureMap.put(oldSubTree.getFeatureName(), newSubTree); - if (!oldSubTree.isSubmodelRoot()) { - for (int i = 0; i < oldSubTree.getChildren().size(); i++) { - for (int j = 0; j < oldSubTree.getChildren().get(i).getFeatures().size(); j++) { - createFeatureReplacementMap(oldSubTree.getChildren().get(i).getFeatures().get(j), newSubTree.getChildren().get(i).getFeatures().get(j), featureFeatureMap); - } - } - } - } - - private void adaptConstraint(Feature subTreeRoot, Constraint constraint, Map featureReplacementMap) { - if (constraint instanceof ExpressionConstraint) { - adaptExpression(((ExpressionConstraint) constraint).getLeft(), featureReplacementMap); - adaptExpression(((ExpressionConstraint) constraint).getRight(), featureReplacementMap); - }else{ - List subParts = constraint.getConstraintSubParts(); - for (Constraint subPart : subParts) { - if (subPart instanceof LiteralConstraint) { - String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); - if (featureReplacementMap.containsKey(toReplace)) { - LiteralConstraint subTreeRootConstraint = new LiteralConstraint(subTreeRoot); - LiteralConstraint newLiteral = new LiteralConstraint(featureReplacementMap.get(toReplace)); - constraint.replaceConstraintSubPart(subPart, newLiteral); - } - } else { - adaptConstraint(subTreeRoot, subPart, featureReplacementMap); - } - } - } - } - - private void adaptExpression(Expression expression, Map featureReplacementMap) { - if (expression instanceof LiteralExpression) { - LiteralExpression literalExpression = (LiteralExpression) expression; - Attribute attribute = (Attribute) literalExpression.getContent(); - if (featureReplacementMap.containsKey(attribute.getFeature().getFeatureName())) { - var newAttribute = attribute.clone(); - newAttribute.setFeature(featureReplacementMap.get(attribute.getFeature().getFeatureName())); - literalExpression.setContent(newAttribute); - } - - }else{ - for (Expression subExpression : expression.getExpressionSubParts()) { - adaptExpression(subExpression, featureReplacementMap); - } - } - } -} diff --git a/src/main/java/de/vill/util/CountingResult.java b/src/main/java/de/vill/util/CountingResult.java deleted file mode 100644 index d314a32..0000000 --- a/src/main/java/de/vill/util/CountingResult.java +++ /dev/null @@ -1,11 +0,0 @@ -package de.vill.util; - -public class CountingResult { - public final Double TIME_TO_COMPUTE; - public final String MODEL_COUNT; - - public CountingResult(Double time, String result) { - this.TIME_TO_COMPUTE = time; - this.MODEL_COUNT = result; - } -} diff --git a/src/main/java/de/vill/util/ModelEvalResult.java b/src/main/java/de/vill/util/ModelEvalResult.java deleted file mode 100644 index 40a4500..0000000 --- a/src/main/java/de/vill/util/ModelEvalResult.java +++ /dev/null @@ -1,27 +0,0 @@ -package de.vill.util; - -public class ModelEvalResult { - public final String MODEL_NAME; - public final Double TIME_TO_COMPUTE_D4; - public final Double TIME_TO_COMPUTE_P2D; - public final String MODEL_COUNT_D4; - public final String MODEL_COUNT_P2D; - public final boolean SAME_RESULT; - public final Double TO_DIMACS_TIME; - public final Double TO_OPB_TIME; - - public ModelEvalResult(String modelName, Double timeToComputeD4, Double timeToComputeP2D, String modelCountD4, String modelCountP2D, boolean sameResult, Double toDimacsTime, Double toOpbTime) { - MODEL_NAME = modelName; - TIME_TO_COMPUTE_D4 = timeToComputeD4; - TIME_TO_COMPUTE_P2D = timeToComputeP2D; - MODEL_COUNT_D4 = modelCountD4; - MODEL_COUNT_P2D = modelCountP2D; - SAME_RESULT = sameResult; - TO_DIMACS_TIME = toDimacsTime; - TO_OPB_TIME = toOpbTime; - } - - public String toCSVString() { - return MODEL_NAME + ";" + TIME_TO_COMPUTE_D4 + ";" + TIME_TO_COMPUTE_P2D + ";" + TO_DIMACS_TIME + ";" + TO_OPB_TIME + ";" + SAME_RESULT + ";" + TIME_TO_COMPUTE_P2D / TIME_TO_COMPUTE_D4 + ";" + TO_OPB_TIME / TO_DIMACS_TIME + ";" + (TIME_TO_COMPUTE_P2D + TO_OPB_TIME) / (TIME_TO_COMPUTE_D4 + TO_DIMACS_TIME); - } -} diff --git a/src/main/java/de/vill/util/SubstitutionVariableIndex.java b/src/main/java/de/vill/util/SubstitutionVariableIndex.java deleted file mode 100644 index 4fbedfa..0000000 --- a/src/main/java/de/vill/util/SubstitutionVariableIndex.java +++ /dev/null @@ -1,30 +0,0 @@ -package de.vill.util; - -public class SubstitutionVariableIndex { - private int index; - private static SubstitutionVariableIndex objectRef; - private SubstitutionVariableIndex() { - index = 0; - } - - public static SubstitutionVariableIndex getInstance() { - if (objectRef == null) { - objectRef = new SubstitutionVariableIndex(); - } - return objectRef; - } - - public String getSubName() { - index++; - return "x_" + index; - } - - public int getIndex() { - index++; - return index; - } - - public int peekIndex(){ - return index; - } -} diff --git a/src/main/java/de/vill/util/Util.java b/src/main/java/de/vill/util/Util.java index 3f17589..759ffda 100644 --- a/src/main/java/de/vill/util/Util.java +++ b/src/main/java/de/vill/util/Util.java @@ -1,21 +1,10 @@ package de.vill.util; import de.vill.config.Configuration; -import de.vill.conversion.ConvertAggregateFunction; -import de.vill.model.building.VariableReference; -import de.vill.model.constraint.*; -import de.vill.model.expression.*; -import de.vill.model.pbc.*; import java.io.IOException; -import java.io.Writer; import java.nio.file.Files; import java.nio.file.Path; -import java.util.HashMap; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; public class Util { public static String indentEachLine(String text) { @@ -59,630 +48,4 @@ public static String readFileContent(Path file) { throw new RuntimeException(e); } } - - public static boolean isJustAnd(Constraint constraint){ - if(constraint instanceof ParenthesisConstraint){ - return isJustAnd(((ParenthesisConstraint) constraint).getContent()); - } - if(constraint instanceof LiteralConstraint){ - return true; - } - if(constraint instanceof NotConstraint){ - return ((NotConstraint) constraint).getContent() instanceof LiteralConstraint; - } - if(constraint instanceof AndConstraint && isJustAnd(((AndConstraint) constraint).getLeft()) && isJustAnd(((AndConstraint) constraint).getRight())){ - return true; - } - return false; - } - - public static Constraint getMaxAndConstraint(Constraint constraint, Map substitutionMapping) { - if (constraint instanceof AndConstraint){ - return new AndConstraint( - getMaxAndConstraint(((AndConstraint) constraint).getLeft(), substitutionMapping), - getMaxAndConstraint(((AndConstraint) constraint).getRight(), substitutionMapping )); - }else{ - return constraint.extractTseitinSubConstraints(substitutionMapping); - } - } - - public static Constraint getMaxOrConstraint(Constraint constraint, Map substitutionMapping) { - if (constraint instanceof OrConstraint){ - return new OrConstraint( - getMaxOrConstraint(((OrConstraint) constraint).getLeft(), substitutionMapping), - getMaxOrConstraint(((OrConstraint) constraint).getRight(), substitutionMapping )); - }else{ - return constraint.extractTseitinSubConstraints(substitutionMapping); - } - } - - public static boolean isJustOr(Constraint constraint){ - if(constraint instanceof ParenthesisConstraint){ - return isJustOr(((ParenthesisConstraint) constraint).getContent()); - } - if(constraint instanceof LiteralConstraint){ - return true; - } - if(constraint instanceof NotConstraint){ - return ((NotConstraint) constraint).getContent() instanceof LiteralConstraint; - } - if(constraint instanceof OrConstraint && isJustOr(((OrConstraint) constraint).getLeft()) && isJustOr(((OrConstraint) constraint).getRight())){ - return true; - } - return false; - } - - public static List transformImplicationMap (HashMap> implicationMap){ - List resultList = new LinkedList<>(); - SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); - for (Map.Entry> entry : implicationMap.entrySet()) { - int index = entry.getKey(); - if (entry.getValue().size() > 1) { - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.k = entry.getValue().size(); - - for(PBConstraint constraint : entry.getValue()){ - String subName = substitutionVariableIndex.getSubName(); - pbConstraint.literalList.add(new Literal( - 1, subName, true - )); - resultList.addAll(substitutionConstraint(constraint, subName)); - } - resultList.addAll(substitutionConstraint(pbConstraint, "x_" + index)); - }else { - for(PBConstraint constraint : entry.getValue()){ - resultList.addAll(substitutionConstraint(constraint, "x_" + index)); - } - } - - - } - return resultList; - } - - public static List substitutionConstraint(PBConstraint constraint, String substitutionName) { - //System.out.println(substitutionName + " <=> " + constraint.toString()); - List resultList = new LinkedList<>(); - // x <=> constraint is the same as -x v constraint AND x v -constraint - // -x v constraint - resultList.addAll(constraint.orWithLiteral(substitutionName, false)); - // x v -constraint - resultList.addAll(constraint.negatedConstraint().orWithLiteral(substitutionName, true)); - return resultList; - } - - public static HashMap> transformSubFormulas(HashMap subformulas, List additionalSubstitution){ - HashMap> resultMap = new HashMap<>(); - for (Map.Entry entry : subformulas.entrySet()) { - resultMap.put(entry.getKey(), transformSubFormula(entry.getValue(), additionalSubstitution)); - } - return resultMap; - } - - public static List transformSubFormula(Constraint constraint, List additionalSubstitution){ - List resultList = new LinkedList<>(); - if(constraint instanceof NotConstraint){ - System.err.println("error"); - System.exit(1); - resultList.add(transformNegLiteral((NotConstraint) constraint)); - } else if (constraint instanceof ImplicationConstraint) { - resultList.add(transformImplication((ImplicationConstraint) constraint)); - } else if (constraint instanceof EquivalenceConstraint) { - resultList.add(transformBiImplication((EquivalenceConstraint) constraint)); - } - else if (constraint instanceof AndConstraint) { - resultList.add(transformAnd((AndConstraint) constraint)); - } - else if (constraint instanceof OrConstraint) { - var orConstraint = transformOr((OrConstraint) constraint); - resultList.add(orConstraint); - } - else if (constraint instanceof ExpressionConstraint) { - ExpressionConstraint expressionConstraint = (ExpressionConstraint) constraint; - resultList.addAll(transformExpression(expressionConstraint, additionalSubstitution)); - }return resultList; - } - - public static PBConstraint transformNegLiteral(NotConstraint constraint){ - Literal literal = new Literal(); - literal.name = ((LiteralConstraint)constraint.getContent()).getReference().getIdentifier(); - literal.factor = -1; - PBConstraint PBConstraint = new PBConstraint(); - PBConstraint.k = 0; - PBConstraint.literalList = new LinkedList<>(); - PBConstraint.literalList.add(literal); - return PBConstraint; - } - - public static PBConstraint transformImplication(ImplicationConstraint constraint){ - PBCLiteralConstraint c1 = (PBCLiteralConstraint) constraint.getLeft(); - PBCLiteralConstraint c2 = (PBCLiteralConstraint) constraint.getRight(); - Literal l1 = new Literal(-1, c1.getReference().getIdentifier(), c1.sign); - Literal l2 = new Literal(1, c2.getReference().getIdentifier(), c2.sign); - - PBConstraint PBConstraint1 = new PBConstraint(); - PBConstraint1.k = 0; - PBConstraint1.literalList.add(l1); - PBConstraint1.literalList.add(l2); - return PBConstraint1; - } - - public static PBConstraint transformBiImplication(EquivalenceConstraint constraint){ - PBCLiteralConstraint c1 = (PBCLiteralConstraint) constraint.getLeft(); - PBCLiteralConstraint c2 = (PBCLiteralConstraint) constraint.getRight(); - Literal l1 = new Literal(1, c1.getReference().getIdentifier(), c1.sign); - Literal l2 = new Literal(-1, c2.getReference().getIdentifier(), c2.sign); - - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.k = 0; - pbConstraint.type = PBConstraintType.EQ; - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.literalList.add(l1); - pbConstraint.literalList.add(l2); - - return pbConstraint; - - } - - public static PBConstraint transformAnd(Constraint constraint){ - if(constraint instanceof AndConstraint){ - PBConstraint PBConstraint1 = transformAnd(((AndConstraint) constraint).getLeft()); - PBConstraint PBConstraint2 = transformAnd(((AndConstraint) constraint).getRight()); - PBConstraint1.k = PBConstraint1.k + PBConstraint2.k; - PBConstraint1.literalList.addAll(PBConstraint2.literalList); - return PBConstraint1; - }else{ - LiteralConstraint c1; - boolean sign; - if (constraint instanceof PBCLiteralConstraint) { - c1 = (LiteralConstraint) constraint; - sign = ((PBCLiteralConstraint)constraint).sign; - }else if (constraint instanceof LiteralConstraint) { - c1 = (LiteralConstraint) constraint; - sign = true; - }else { - c1 = (LiteralConstraint) ((NotConstraint) constraint).getContent(); - sign = false; - } - Literal l1 = new Literal(); - PBConstraint PBConstraint = new PBConstraint(); - - l1.name = c1.getReference().getIdentifier(); - l1.factor = 1; - l1.sign = sign; - PBConstraint.k = 1; - - PBConstraint.literalList = new LinkedList<>(); - PBConstraint.literalList.add(l1); - return PBConstraint; - } - } - - public static PBConstraint transformOr(Constraint constraint){ - if(constraint instanceof OrConstraint){ - PBConstraint PBConstraint1 = transformOr(((OrConstraint) constraint).getLeft()); - PBConstraint PBConstraint2 = transformOr(((OrConstraint) constraint).getRight()); - PBConstraint1.literalList.addAll(PBConstraint2.literalList); - return PBConstraint1; - }else { - LiteralConstraint c1; - boolean sign; - if (constraint instanceof PBCLiteralConstraint) { - c1 = (LiteralConstraint) constraint; - sign = ((PBCLiteralConstraint)constraint).sign;; - }else if (constraint instanceof LiteralConstraint) { - c1 = (LiteralConstraint) constraint; - sign = true; - }else { - c1 = (LiteralConstraint) ((NotConstraint) constraint).getContent(); - sign = false; - } - Literal l1 = new Literal(); - PBConstraint PBConstraint = new PBConstraint(); - - l1.name = c1.getReference().getIdentifier(); - l1.factor = 1; - l1.sign = sign; - PBConstraint.k = 1; - - PBConstraint.literalList = new LinkedList<>(); - PBConstraint.literalList.add(l1); - return PBConstraint; - } - } - - public static List transformExpression(ExpressionConstraint constraint, List additionalSubstitution) { - List additionalConstraints = new LinkedList<>(); - List allDenominators = new LinkedList<>(); - collectDenominators(constraint.getLeft(), allDenominators); - collectDenominators(constraint.getRight(), allDenominators); - additionalConstraints.addAll(getConstraintsToForbidZeroDivision(allDenominators)); - - //transform everything to a sum - var leftSum = constraint.getLeft().getAsSum(additionalSubstitution); - var rightSum = constraint.getRight().getAsSum(additionalSubstitution); - //take all numbers to the right side - List numbersFromLeftToRight = leftSum.stream().filter(x -> x.name == null).collect(Collectors.toList()); - for (Literal l : numbersFromLeftToRight){ - l.factor *= -1; - } - rightSum.addAll(numbersFromLeftToRight); - leftSum = leftSum.stream().filter(x -> x.name != null).collect(Collectors.toList()); - //take all variables with factors to the left side - List numbersFromRightToLeft = rightSum.stream().filter(x -> x.name != null).collect(Collectors.toList()); - for (Literal l : numbersFromRightToLeft){ - l.factor *= -1; - } - leftSum.addAll(numbersFromRightToLeft); - rightSum = rightSum.stream().filter(x -> x.name == null).collect(Collectors.toList()); - - //sum app factors with same variable - HashMap literalMap = new HashMap<>(); - for (Literal l : leftSum) { - if (literalMap.containsKey(l.name)) { - literalMap.put(l.name, literalMap.get(l.name) + l.factor); - }else{ - literalMap.put(l.name, l.factor); - } - } - - //create constraint - PBConstraint pbConstraint = new PBConstraint(); - if ("==".equals(constraint.getExpressionSymbol())) { - pbConstraint.type = PBConstraintType.EQ; - } else if ("<".equals(constraint.getExpressionSymbol())) { - pbConstraint.type = PBConstraintType.LE; - } else if (">".equals(constraint.getExpressionSymbol())) { - pbConstraint.type = PBConstraintType.GE; - } else if (">=".equals(constraint.getExpressionSymbol())) { - pbConstraint.type = PBConstraintType.GEQ; - } else if ("<=".equals(constraint.getExpressionSymbol())) { - pbConstraint.type = PBConstraintType.LEQ; - } else if ("!=".equals(constraint.getExpressionSymbol())) { - pbConstraint.type = PBConstraintType.NOTEQ; - } - pbConstraint.k = rightSum.stream().map(x -> x.factor).reduce(0.0, Double::sum); - pbConstraint.literalList = new LinkedList<>(); - for (Map.Entry e : literalMap.entrySet()) { - pbConstraint.literalList.add(new Literal(e.getValue(), e.getKey(), true)); - } - - additionalConstraints.add(pbConstraint); - - return additionalConstraints; - } - - public static void collectDenominators(Expression expression, List denominators) { - if (expression instanceof DivExpression){ - denominators.add(((DivExpression) expression).getRight()); - } - for (Expression subExpression : expression.getExpressionSubParts()){ - collectDenominators(subExpression, denominators); - } - } - - public static Expression removeAllDenominators(Expression expression) { - if (expression instanceof DivExpression){ - return removeAllDenominators(((DivExpression) expression).getLeft()); - }else { - HashMap newSubParts = new HashMap<>(); - for (Expression subExpression : expression.getExpressionSubParts()){ - newSubParts.put(subExpression, removeAllDenominators(subExpression)); - } - for (Map.Entry entry : newSubParts.entrySet()){ - expression.replaceExpressionSubPart(entry.getKey(), entry.getValue()); - } - return expression; - } - } - - public static List getConstraintsToForbidZeroDivision(List denominators) { - List additionalConstraints = new LinkedList<>(); - for (Expression denominator : denominators){ - removeAllDenominators(denominator); - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.k = 0; - pbConstraint.type = PBConstraintType.NOTEQ; - pbConstraint.literalList = new LinkedList<>(); - for (Literal l : denominator.getAsSum(additionalConstraints)) { - pbConstraint.literalList.add(l); - } - additionalConstraints.add(pbConstraint); - } - return additionalConstraints; - } - - static int counter = 0; - public static void constraintDistributiveToOPB(Constraint constraint, OPBResult result, Writer writer) throws IOException { - constraint = substituteExpressions(constraint, result); - constraint = removeParenthesisConstraint(constraint); - constraint = removeBiimplication(constraint); - constraint = removeImplication(constraint); - constraint = pushDownNegation(constraint); - System.out.println(constraint.toString()); - System.out.println(counter); - if (counter == 74){ - System.out.println("test"); - } - - constraint = distributeOrOverAnd(constraint, 0); - //cnfToOpb(constraint,writer); - constraint = null; - counter++; - } - - private static void cnfToOpb(Constraint constraint, Writer writer) throws IOException { - if (constraint instanceof OrConstraint || constraint instanceof NotConstraint || constraint instanceof LiteralConstraint) { - int negatives = clauseToOpb(constraint, writer); - writer.write(" >= "); - writer.write(String.valueOf(1 - negatives)); - writer.write(";\n"); - }else { - var and = (AndConstraint) constraint; - if (and.getLeft() instanceof AndConstraint){ - cnfToOpb(and.getLeft(), writer); - }else{ - int negatives = clauseToOpb(and.getLeft(), writer); - writer.write(" >= "); - writer.write(String.valueOf(1 - negatives)); - writer.write(";\n"); - } - - if (and.getRight() instanceof AndConstraint){ - cnfToOpb(and.getRight(), writer); - }else{ - int negatives = clauseToOpb(and.getRight(), writer); - writer.write(" >= "); - writer.write(String.valueOf(1 - negatives)); - writer.write(";\n"); - } - } - } - - private static int clauseToOpb(Constraint constraint, Writer writer) throws IOException { - int negatives = 0; - if (constraint instanceof NotConstraint) { - writer.write(" -1 * "); - var literal = (LiteralConstraint)((NotConstraint) constraint).getContent(); - writer.write('"'); - writer.write(literal.getReference().getIdentifier()); - writer.write('"'); - negatives++; - }else if (constraint instanceof LiteralConstraint){ - writer.append(" +1 * "); - var literal = (LiteralConstraint)constraint; - writer.write('"'); - writer.write(literal.getReference().getIdentifier()); - writer.write('"'); - }else { - var or = (OrConstraint)constraint; - negatives += clauseToOpb(or.getLeft(), writer); - negatives += clauseToOpb(or.getRight(), writer); - } - return negatives; - } - - private static Constraint removeParenthesisConstraint(Constraint constraint){ - if (constraint instanceof ParenthesisConstraint){ - return removeParenthesisConstraint(((ParenthesisConstraint) constraint).getContent()); - }else{ - for (Constraint subConstraint : constraint.getConstraintSubParts()){ - constraint.replaceConstraintSubPart(subConstraint, removeParenthesisConstraint(subConstraint)); - } - } - return constraint; - } - - public static Constraint substituteExpressions(Constraint constraint, OPBResult result){ - if (constraint instanceof ExpressionConstraint){ - SubstitutionVariableIndex substitutionVariableIndex = SubstitutionVariableIndex.getInstance(); - int subIndex = substitutionVariableIndex.getIndex(); - String subName = "x_" + subIndex; - LiteralConstraint subLiteral = new LiteralConstraint(new VariableReference() { - @Override - public String getIdentifier() { - return subName; - } - }); - HashMap> subMap = new HashMap<>(); - List additionalSubs = new LinkedList<>(); - List expressionEncoding = transformExpression((ExpressionConstraint) constraint, additionalSubs); - subMap.put(subIndex, expressionEncoding); - List resultList = transformImplicationMap(subMap); - resultList.addAll(additionalSubs); - for (PBConstraint pbConstraint : resultList){ - pbConstraint.toOPBString(result); - } - return subLiteral; - }else{ - for (Constraint subConstraint : constraint.getConstraintSubParts()){ - constraint.replaceConstraintSubPart(subConstraint, substituteExpressions(subConstraint, result)); - } - } - return constraint; - } - - private static Constraint removeImplication(Constraint constraint){ - if (constraint instanceof ImplicationConstraint) { - return new OrConstraint( - new NotConstraint( - removeImplication(((ImplicationConstraint) constraint).getLeft())), - removeImplication(((ImplicationConstraint) constraint).getRight()) - ); - }else{ - for (Constraint subConstraint : constraint.getConstraintSubParts()){ - constraint.replaceConstraintSubPart(subConstraint, removeImplication(subConstraint)); - } - } - return constraint; - } - - private static Constraint removeBiimplication(Constraint constraint){ - if (constraint instanceof EquivalenceConstraint) { - return new AndConstraint( - new OrConstraint( - new NotConstraint( - removeBiimplication(((EquivalenceConstraint) constraint).getLeft()) - ), - removeBiimplication(((EquivalenceConstraint) constraint).getRight())), - new OrConstraint( - new NotConstraint( - removeBiimplication(((EquivalenceConstraint) constraint).getRight())), - removeBiimplication(((EquivalenceConstraint) constraint).getLeft())) - ); - }else{ - for (Constraint subConstraint : constraint.getConstraintSubParts()){ - constraint.replaceConstraintSubPart(subConstraint, removeBiimplication(subConstraint)); - } - } - return constraint; - } - - private static Constraint pushDownNegation(Constraint constraint){ - if (constraint instanceof NotConstraint) { - var notConstraint = (NotConstraint) constraint; - if (notConstraint.getContent() instanceof AndConstraint){ - return pushDownNegation( - new OrConstraint( - new NotConstraint(((AndConstraint) notConstraint.getContent()).getLeft()), - new NotConstraint(((AndConstraint) notConstraint.getContent()).getRight()) - ) - ); - }else if (notConstraint.getContent() instanceof OrConstraint){ - return pushDownNegation( - new AndConstraint( - new NotConstraint(((OrConstraint) notConstraint.getContent()).getLeft()), - new NotConstraint(((OrConstraint) notConstraint.getContent()).getRight()) - ) - ); - }else if (notConstraint.getContent() instanceof NotConstraint){ - return pushDownNegation( - ((NotConstraint) notConstraint.getContent()).getContent() - ); - }else { - return notConstraint; - } - }else { - for (Constraint subConstraint : constraint.getConstraintSubParts()){ - constraint.replaceConstraintSubPart(subConstraint, pushDownNegation(subConstraint)); - } - } - return constraint; - } - - public static void encodeConstraintTseitinStyle(Constraint constraint, OPBResult result){ - if (constraint instanceof LiteralConstraint){ - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = 1; - Literal literal = new Literal(1, ((LiteralConstraint) constraint).getReference().getIdentifier(), true); - pbConstraint.literalList.add(literal); - result.numberVariables++; - pbConstraint.toOPBString(result); - return; - } - HashMap subMap = new HashMap<>(); - constraint.extractTseitinSubConstraints(subMap); - - if (subMap.isEmpty()) { - if (constraint instanceof LiteralConstraint){ - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = 1; - Literal literal = new Literal(1, ((LiteralConstraint) constraint).getReference().getIdentifier(), true); - pbConstraint.literalList.add(literal); - result.numberVariables++; - pbConstraint.toOPBString(result); - return; - }else if(constraint instanceof NotConstraint){ - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = 0; - Literal literal = new Literal(-1, ((LiteralConstraint)((NotConstraint)constraint).getContent()).getReference().getIdentifier(), true); - pbConstraint.literalList.add(literal); - result.numberVariables++; - pbConstraint.toOPBString(result); - return; - } - } - - boolean sign = !(constraint instanceof NotConstraint); - Literal literal = new Literal(1, "x_" + SubstitutionVariableIndex.getInstance().peekIndex(), sign); - - List additionalSubstitutionConstraints = new LinkedList<>(); - var map = transformSubFormulas(subMap, additionalSubstitutionConstraints); - List pbcList = transformImplicationMap(map); - PBConstraint pbConstraint = new PBConstraint(); - pbConstraint.literalList = new LinkedList<>(); - pbConstraint.k = 1; - - pbConstraint.literalList.add(literal); - pbcList.add(pbConstraint); - pbcList.addAll(additionalSubstitutionConstraints); - for(PBConstraint pBConstraint : pbcList){ - result.numberVariables++; - pBConstraint.toOPBString(result); - } - } - - private static Constraint distributeOrOverAnd(Constraint constraint, int d) { - if (counter == 74 && d >= 20) { - System.out.println("test"); - } - d++; - if (constraint instanceof OrConstraint) { - OrConstraint or = (OrConstraint) constraint; - Constraint left = distributeOrOverAnd(or.getLeft(), d); - Constraint right = distributeOrOverAnd(or.getRight(), d); - - if (left instanceof AndConstraint) { - AndConstraint leftAnd = (AndConstraint) left; - leftAnd.setLeft(distributeOrOverAnd(new OrConstraint(leftAnd.getLeft(), right),d)); - leftAnd.setRight(distributeOrOverAnd(new OrConstraint(leftAnd.getRight(), right),d)); - return leftAnd; - /* - return new AndConstraint( - distributeOrOverAnd(new OrConstraint(leftAnd.getLeft(), right)), - distributeOrOverAnd(new OrConstraint(leftAnd.getRight(), right)) - ); - - */ - } else if (right instanceof AndConstraint) { - AndConstraint rightAnd = (AndConstraint) right; - rightAnd.setLeft(distributeOrOverAnd(new OrConstraint(left, rightAnd.getLeft()),d)); - rightAnd.setRight(distributeOrOverAnd(new OrConstraint(left, rightAnd.getRight()),d)); - return rightAnd; - /* - return new AndConstraint( - distributeOrOverAnd(new OrConstraint(left, rightAnd.getLeft())), - distributeOrOverAnd(new OrConstraint(left, rightAnd.getRight())) - ); - - */ - } - // - or.setLeft(left); - or.setRight(right); - return constraint; - //return new OrConstraint(left, right); - } else if (constraint instanceof AndConstraint) { - // - AndConstraint and = (AndConstraint) constraint; - Constraint left = distributeOrOverAnd(and.getLeft(),d); - Constraint right = distributeOrOverAnd(and.getRight(),d); - and.setLeft(left); - and.setRight(right); - return and; - /* - return new AndConstraint( - distributeOrOverAnd(and.getLeft()), - distributeOrOverAnd(and.getRight()) - ); - - */ - } - - return constraint; - } - } From 5f6c0384057dd01a02329185ebdbd8cf2104aca8 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 19 Dec 2024 12:48:03 +0100 Subject: [PATCH 49/60] fix: use multior in smt conversion to prevent stack overflow --- src/main/java/de/vill/conversion/ConvertSMTLevel.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/de/vill/conversion/ConvertSMTLevel.java b/src/main/java/de/vill/conversion/ConvertSMTLevel.java index e1a9e5f..0ac48f9 100644 --- a/src/main/java/de/vill/conversion/ConvertSMTLevel.java +++ b/src/main/java/de/vill/conversion/ConvertSMTLevel.java @@ -138,6 +138,11 @@ private Constraint createConjunction(Set selectedFeatures, Set } private Constraint createDisjunction(Set constraints) { + MultiOrConstraint orConstraint = new MultiOrConstraint(); + for (Constraint constraint : constraints) { + orConstraint.add_sub_part(constraint); + } + /* Constraint orConstraint; if (constraints.size() == 1) { Constraint constraint = constraints.iterator().next(); @@ -149,6 +154,8 @@ private Constraint createDisjunction(Set constraints) { orConstraint = new OrConstraint(constraint, createDisjunction(constraints)); } + */ + return orConstraint; } From a606dc181e6bbbfedabbb75c0c1192ae8204bafa Mon Sep 17 00:00:00 2001 From: Stefan Date: Sun, 19 Jan 2025 20:58:40 +0100 Subject: [PATCH 50/60] fix: drop typelevel conversion also considers constraints with type related concepts --- .../de/vill/conversion/DropTypeLevel.java | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/src/main/java/de/vill/conversion/DropTypeLevel.java b/src/main/java/de/vill/conversion/DropTypeLevel.java index 95a24d6..c00a15c 100644 --- a/src/main/java/de/vill/conversion/DropTypeLevel.java +++ b/src/main/java/de/vill/conversion/DropTypeLevel.java @@ -1,9 +1,15 @@ package de.vill.conversion; +import de.vill.main.Example; import de.vill.model.Feature; import de.vill.model.FeatureModel; import de.vill.model.Group; import de.vill.model.LanguageLevel; +import de.vill.model.constraint.Constraint; +import de.vill.model.constraint.ExpressionConstraint; +import de.vill.model.expression.Expression; +import de.vill.model.expression.LengthAggregateFunctionExpression; +import de.vill.model.expression.StringExpression; import de.vill.util.Constants; import java.util.Collections; @@ -24,6 +30,7 @@ public Set getTargetLevelsOfConversion() { @Override public void convertFeatureModel(final FeatureModel rootFeatureModel, final FeatureModel featureModel) { this.traverseFeatures(featureModel.getRootFeature()); + traverseConstraints(featureModel); } private void traverseFeatures(final Feature feature) { @@ -37,4 +44,44 @@ private void traverseFeatures(final Feature feature) { } } } + + private void traverseConstraints(FeatureModel featureModel) { + for(Constraint constraint : featureModel.getConstraints()){ + if (containsTypeConcept(constraint)){ + featureModel.getOwnConstraints().remove(constraint); + } + } + } + + private boolean containsTypeConcept(Constraint constraint) { + if (constraint instanceof ExpressionConstraint){ + for(Expression subExpression : ((ExpressionConstraint) constraint).getExpressionSubParts()){ + if (containsTypeConcept(subExpression)){ + return true; + } + } + + } + for(Constraint subConstraints : constraint.getConstraintSubParts()){ + if (containsTypeConcept(subConstraints)){ + return true; + } + } + return false; + } + + private boolean containsTypeConcept(Expression expression) { + if (expression instanceof LengthAggregateFunctionExpression){ + return true; + } + if (expression instanceof StringExpression){ + return true; + } + for(Expression subExpressions : expression.getExpressionSubParts()){ + if (containsTypeConcept(subExpressions)){ + return true; + } + } + return false; + } } From 44a90bb20b7322f1b3eae0a75fb28e1339134a29 Mon Sep 17 00:00:00 2001 From: Stefan <76208574+st-vi@users.noreply.github.com> Date: Wed, 22 Jan 2025 19:52:40 +0100 Subject: [PATCH 51/60] Delete .idea/.gitignore --- .idea/.gitignore | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 .idea/.gitignore diff --git a/.idea/.gitignore b/.idea/.gitignore deleted file mode 100644 index 26d3352..0000000 --- a/.idea/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -# Default ignored files -/shelf/ -/workspace.xml From 6b1dd6695b8123d817b2948e8fbe58951f687175 Mon Sep 17 00:00:00 2001 From: Stefan <76208574+st-vi@users.noreply.github.com> Date: Wed, 22 Jan 2025 19:52:52 +0100 Subject: [PATCH 52/60] Delete .idea directory --- .idea/compiler.xml | 13 ------------- .idea/encodings.xml | 7 ------- .idea/jarRepositories.xml | 20 -------------------- .idea/misc.xml | 12 ------------ .idea/vcs.xml | 6 ------ 5 files changed, 58 deletions(-) delete mode 100644 .idea/compiler.xml delete mode 100644 .idea/encodings.xml delete mode 100644 .idea/jarRepositories.xml delete mode 100644 .idea/misc.xml delete mode 100644 .idea/vcs.xml diff --git a/.idea/compiler.xml b/.idea/compiler.xml deleted file mode 100644 index 59b2d44..0000000 --- a/.idea/compiler.xml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/.idea/encodings.xml b/.idea/encodings.xml deleted file mode 100644 index aa00ffa..0000000 --- a/.idea/encodings.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - \ No newline at end of file diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml deleted file mode 100644 index 712ab9d..0000000 --- a/.idea/jarRepositories.xml +++ /dev/null @@ -1,20 +0,0 @@ - - - - - - - - - - - \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml deleted file mode 100644 index f0f8287..0000000 --- a/.idea/misc.xml +++ /dev/null @@ -1,12 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml deleted file mode 100644 index 35eb1dd..0000000 --- a/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file From 2f49f18debd081717d79912a107a09bb7a9e2d10 Mon Sep 17 00:00:00 2001 From: Stefan Date: Wed, 22 Jan 2025 19:53:12 +0100 Subject: [PATCH 53/60] refactor: removed unnecessary files --- model.uvl | 45 - subModels/Server.uvl | 21 - submodels/FBTree.uvl | 19 - submodels/FConcurrency.uvl | 11 - submodels/FLogging.uvl | 19 - submodels/FPersistency.uvl | 39 - submodels/FStatistics.uvl | 27 - test.uvl | 6241 ------------------------------------ test2.uvl | 10 - test_composedModel.uvl | 21 - test_singleModel.uvl | 21 - 11 files changed, 6474 deletions(-) delete mode 100644 model.uvl delete mode 100644 subModels/Server.uvl delete mode 100644 submodels/FBTree.uvl delete mode 100644 submodels/FConcurrency.uvl delete mode 100644 submodels/FLogging.uvl delete mode 100644 submodels/FPersistency.uvl delete mode 100644 submodels/FStatistics.uvl delete mode 100644 test.uvl delete mode 100644 test2.uvl delete mode 100644 test_composedModel.uvl delete mode 100644 test_singleModel.uvl diff --git a/model.uvl b/model.uvl deleted file mode 100644 index 602e9f4..0000000 --- a/model.uvl +++ /dev/null @@ -1,45 +0,0 @@ -namespace BerkeleyDb - -imports - submodels.FLogging as fl - submodels.FBTree as fbt - submodels.FPersistency as fp - submodels.FConcurrency as fc - submodels.FStatistics as fs - -features - BerkeleyDb {abstract true} - optional - BerkeleyDB {abstract true} - mandatory - BASE - fp.FPersistency - fbt.FBtree - optional - fl.FLogging - fs.FStatistics - fc.FConcurrency - featureMemoryBudget - FDbOperation {abstract true} - or - featureDeleteDb - featureTruncateDb - -constraints - fbt.featureEvictor | fbt.featureEvictorDaemon | fp.featureLookAheadCache | fs.featureStatisticsEnvCaching => featureMemoryBudget - fc.featureCheckLeaks => fs.featureStatisticsLock - fbt.featureCriticalEviction => fbt.featureINCompressor - fp.featureCustomizableCheckpointerBytes => fp.featureCustomizableCheckpointerTime - featureDeleteDb => fc.dummyFeatureLocking & fbt.featureEvictor & fbt.featureINCompressor & featureMemoryBudget - fc.featureLatch => fc.dummyFeatureLocking & fc.featureCheckLeaks & featureDeleteDb & fbt.featureEvictor & fp.featureFileHandleCache & fc.featureFSync & fbt.featureINCompressor & featureMemoryBudget & fs.featureStatisticsLock & fbt.featureTreeVisitor & featureTruncateDb & fbt.featureVerifier - fl.featureLoggingFine => fc.dummyFeatureLocking & fbt.featureEvictor & fbt.featureINCompressor - fl.featureLoggingBase | fl.featureLoggingFinest => fc.featureTransaction - featureMemoryBudget => fbt.featureEvictor & fc.featureLatch - fs.featureStatisticsLock | fs.featureStatisticsTransaction => fc.dummyFeatureLocking - fs.featureStatisticsEnvEvictor => fbt.featureEvictor - fs.featureStatisticsEnvFSync => fc.featureFSync - fs.featureStatisticsTransaction => fc.featureTransaction - fs.featureStatisticsDatabase => fbt.featureTreeVisitor - fc.featureTransaction => fc.dummyFeatureLocking & featureDeleteDb & featureTruncateDb - featureTruncateDb => featureDeleteDb - fbt.featureVerifier => fbt.featureINCompressor & fbt.featureTreeVisitor diff --git a/subModels/Server.uvl b/subModels/Server.uvl deleted file mode 100644 index 7ce77e9..0000000 --- a/subModels/Server.uvl +++ /dev/null @@ -1,21 +0,0 @@ -namespace Server - -features - Server {abstract true} - mandatory - FileSystem - or - NTFS - APFS - EXT4 - OperatingSystem {abstract true} - alternative - Windows - macOS - Debian - optional - Logging {log_level 2, default true} - -constraints - Windows => NTFS - macOS => APFS diff --git a/submodels/FBTree.uvl b/submodels/FBTree.uvl deleted file mode 100644 index 70fd097..0000000 --- a/submodels/FBTree.uvl +++ /dev/null @@ -1,19 +0,0 @@ -namespace FBTree - -features - FBtree {abstract true} - optional - BTree {abstract true} - optional - featureVerifier - featureTreeVisitor - featureINCompressor - FEvictor {abstract true} - optional - Evictor {abstract true} - mandatory - featureEvictor - optional - featureCriticalEviction - featureEvictorDaemon - diff --git a/submodels/FConcurrency.uvl b/submodels/FConcurrency.uvl deleted file mode 100644 index 88a6efc..0000000 --- a/submodels/FConcurrency.uvl +++ /dev/null @@ -1,11 +0,0 @@ -namespace FConcurrency - -features - FConcurrency {abstract true} - or - featureLatch - featureFSync - featureTransaction - dummyFeatureLocking - featureCheckLeaks - diff --git a/submodels/FLogging.uvl b/submodels/FLogging.uvl deleted file mode 100644 index 5f0f419..0000000 --- a/submodels/FLogging.uvl +++ /dev/null @@ -1,19 +0,0 @@ -namespace FLogging - -features - FLogging {abstract true} - optional - Logging {abstract true} - mandatory - featureLoggingBase - optional - featureLoggingFile - featureLoggingConsole - featureLoggingDbLog - featureLoggingFinest - featureLoggingFiner - featureLoggingFine - featureLoggingInfo - featureLoggingConfig - featureLoggingSevere - diff --git a/submodels/FPersistency.uvl b/submodels/FPersistency.uvl deleted file mode 100644 index e89ae5b..0000000 --- a/submodels/FPersistency.uvl +++ /dev/null @@ -1,39 +0,0 @@ -namespace FPersistency - -features - FPersistency {abstract true} - optional - Persistency {abstract true} - mandatory - FIOFeature {abstract true} - alternative - NIO {abstract true} - mandatory - FNIOType {abstract true} - alternative - featureNIO - featureChunkedNIO - optional - featureDirectNIO - IO {abstract true} - mandatory - featureIO - optional - featureSynchronizedIO - optional - FPersistencyFeatures {abstract true} - or - featureChecksum - featureFileHandleCache - featureHandleFullDiscError - featureEnvironmentLock - Checkpointer {abstract true} - optional - featureCustomizableCheckpointerTime - featureCustomizableCheckpointerBytes - featureCheckpointerDaemon - Cleaner {abstract true} - optional - featureLookAheadCache - featureCleanerDaemon - diff --git a/submodels/FStatistics.uvl b/submodels/FStatistics.uvl deleted file mode 100644 index a29f4c4..0000000 --- a/submodels/FStatistics.uvl +++ /dev/null @@ -1,27 +0,0 @@ -namespace FStatistics - -features - FStatistics {abstract true} - optional - Statistics {abstract true} - mandatory - FStatisticsFeatures {abstract true} - or - EnvStats {abstract true} - mandatory - featureStatisticsEnvBase - optional - featureStatisticsEnvLog - featureStatisticsEnvINCompressor - featureStatisticsEnvFSync - featureStatisticsEnvEvictor - featureStatisticsEnvCleaner - featureStatisticsEnvCheckpointer - featureStatisticsEnvCaching - featureStatisticsDatabase - featureStatisticsLock - featureStatisticsPreload - featureStatisticsSequence - featureStatisticsTransaction - featureStatisticsBase - diff --git a/test.uvl b/test.uvl deleted file mode 100644 index 5d216a4..0000000 --- a/test.uvl +++ /dev/null @@ -1,6241 +0,0 @@ -features - "N_100000__F_100001" - mandatory - "N_100002__F_100003" - mandatory - "N_100002__F_100012" - alternative - "N_100002__F_100013" - mandatory - "N_100002__F_100014" - mandatory - "N_100002__F_100014_xor" {abstract} - alternative - N_100002__F_100015 - N_100002__F_100016 - "N_100002__F_100017" - alternative - N_100002__F_100018 - N_100002__F_100019 - - optional - "N_100002__F_100020" - alternative - N_100002__F_100021 - N_100002__F_100022 - N_100002__F_100023 - N_100002__F_100024 - "N_100002__F_100025" - alternative - N_100002__F_100026 - N_100002__F_100027 - N_100002__F_100028 - "N_100002__F_100029" - mandatory - "N_100002__F_100030" - alternative - N_100002__F_100031 - N_100002__F_100032 - N_100002__F_100033 - "N_100002__F_100029_or" {abstract} - or - "N_100002__F_100034" - optional - N_100002__F_100035 - "N_100002__F_100036" - or - "N_100002__I_100039_i_F_100037" - optional - N_100002__I_100039_i_F_100040 - "N_100002__I_100045_i_F_100043" - optional - N_100002__I_100045_i_F_100046 - "N_100002__I_100051_i_F_100049" - optional - N_100002__I_100051_i_F_100052 - "N_100002__I_100057_i_F_100055" - optional - N_100002__I_100057_i_F_100058 - "N_100002__I_100063_i_F_100061" - optional - N_100002__I_100063_i_F_100064 - "N_100002__I_100069_i_F_100067" - optional - N_100002__I_100069_i_F_100070 - - optional - "N_100002__F_100073" - alternative - N_100002__F_100074 - N_100002__F_100075 - N_100002__F_100076 - N_100002__F_100077 - N_100002__F_100078 - "N_100002__F_100079" - optional - "N_100002__F_100080" - alternative - N_100002__F_100081 - N_100002__F_100082 - N_100002__F_100083 - N_100002__F_100084 - N_100002__F_100085 - N_100002__F_100086 - "N_100002__F_100087" - alternative - N_100002__F_100088 - N_100002__F_100089 - N_100002__F_100090 - N_100002__F_100091 - N_100002__F_100092 - N_100002__F_100093 - N_100002__F_100094 - "N_100002__F_100095" - alternative - N_100002__F_100096 - N_100002__F_100097 - N_100002__F_100098 - N_100002__F_100099 - N_100002__F_100100 - N_100002__F_100101 - N_100002__F_100102 - N_100002__F_100103 - N_100002__F_100104 - N_100002__F_100105 - "N_100002__F_100106" - alternative - N_100002__F_100107 - N_100002__F_100108 - N_100002__F_100109 - "N_100002__F_100113" - alternative - "N_100002__F_100114" - alternative - N_100002__F_100115 - N_100002__F_100116 - N_100002__F_100117 - N_100002__F_100118 - N_100002__F_100119 - N_100002__F_100120 - N_100002__F_100121 - N_100002__F_100122 - N_100002__F_100123 - N_100002__F_100124 - N_100002__F_100125 - N_100002__F_100126 - N_100002__F_100127 - N_100002__F_100128 - N_100002__F_100129 - - optional - "N_100002__F_100004" - alternative - "N_100002__F_100005" - optional - N_100002__F_100006 - N_100002__F_100007 - N_100002__F_100008 - N_100002__F_100009 - N_100002__F_100010 - N_100002__F_100011 - "N_100002__F_100110" - optional - N_100002__F_100111 - N_100002__F_100112 - "N_100130__F_100131" - alternative - "N_100130__F_100132" - mandatory - "N_100130__F_100133" - mandatory - "N_100130__F_100134" - optional - "N_100130__F_100135" - optional - N_100130__F_100136 - N_100130__F_100137 - "N_100130__F_100138" - mandatory - N_100130__F_100139 - - optional - N_100130__F_100140 - N_100130__F_100141 - N_100130__F_100142 - N_100130__F_100143 - N_100130__F_100144 - N_100130__F_100145 - - optional - "N_100130__F_100146" - or - N_100130__F_100147 - "N_100130__F_100148" - optional - N_100130__F_100149 - N_100130__F_100150 - N_100130__F_100151 - N_100130__F_100152 - "N_100130__F_100153" - optional - N_100130__F_100154 - N_100130__F_100155 - N_100130__F_100156 - N_100130__F_100157 - N_100130__F_100158 - N_100130__F_100159 - - optional - "N_100130__F_100160" - optional - "N_100130__F_100161" - optional - N_100130__F_100162 - N_100130__F_100163 - N_100130__F_100164 - N_100130__F_100165 - N_100130__F_100166 - N_100130__F_100167 - N_100130__F_100168 - N_100130__F_100169 - "N_100130__F_100170" - optional - "N_100130__F_100171" - optional - N_100130__F_100172 - "N_100130__F_100173" - optional - "N_100130__F_100174" - or - "N_100130__F_100175" - alternative - N_100130__F_100176 - N_100130__F_100177 - N_100130__F_100178 - "N_100130__F_100179" - alternative - N_100130__F_100180 - N_100130__F_100181 - N_100130__F_100182 - "N_100130__F_100183" - alternative - N_100130__F_100184 - N_100130__F_100185 - N_100130__F_100186 - "N_100130__F_100187" - or - "N_100130__F_100188" - alternative - N_100130__F_100189 - N_100130__F_100190 - N_100130__F_100191 - "N_100130__F_100192" - alternative - N_100130__F_100193 - N_100130__F_100194 - N_100130__F_100195 - "N_100130__F_100196" - alternative - N_100130__F_100197 - N_100130__F_100198 - N_100130__F_100199 - "N_100130__F_100200" - optional - N_100130__F_100201 - "N_100130__F_100202" - alternative - "N_100130__F_100203" - mandatory - "N_100130__F_100203_xor" {abstract} - alternative - N_100130__F_100204 - N_100130__F_100205 - N_100130__F_100206 - - optional - N_100130__F_100207 - "N_100130__F_100208" - alternative - N_100130__F_100209 - N_100130__F_100210 - N_100130__F_100211 - "N_100130__F_100212" - mandatory - "N_100130__F_100212_xor" {abstract} - alternative - N_100130__F_100213 - N_100130__F_100214 - N_100130__F_100215 - - optional - N_100130__F_100216 - "N_100130__F_100217" - optional - "N_100130__F_100218" - optional - N_100130__F_100219 - N_100130__F_100220 - N_100130__F_100221 - N_100130__F_100222 - N_100130__F_100223 - N_100130__F_100224 - "N_100130__F_100225" - mandatory - "N_100130__F_100226" - alternative - N_100130__F_100227 - N_100130__F_100228 - "N_100130__F_100229" - mandatory - N_100130__F_100230 - - optional - N_100130__F_100231 - N_100130__F_100232 - - optional - N_100130__F_100233 - N_100130__F_100234 - N_100130__F_100235 - N_100130__F_100236 - N_100130__F_100237 - N_100130__F_100238 - "N_100130__F_100239" - optional - N_100130__F_100240 - N_100130__F_100241 - N_100130__F_100242 - N_100130__F_100243 - N_100130__F_100244 - N_100130__F_100245 - N_100130__F_100246 - N_100130__F_100247 - N_100130__F_100248 - N_100130__F_100249 - N_100130__F_100250 - N_100130__F_100251 - N_100130__F_100252 - "N_100130__F_100253" - mandatory - N_100130__F_100254 - N_100130__F_100255 - - optional - N_100130__F_100256 - N_100130__F_100257 - N_100130__F_100258 - N_100130__F_100259 - N_100130__F_100260 - N_100130__F_100261 - N_100130__F_100262 - N_100130__F_100263 - N_100130__F_100264 - "N_100130__F_100265" - optional - N_100130__F_100266 - N_100130__F_100267 - "N_100130__F_100268" - or - N_100130__F_100269 - N_100130__F_100270 - "N_100130__F_100271" - optional - N_100130__F_100272 - N_100130__F_100273 - N_100130__F_100274 - "N_100130__F_100275" - optional - N_100130__F_100276 - N_100130__F_100277 - N_100130__F_100278 - "N_100130__F_100279" - optional - N_100130__F_100280 - N_100130__F_100281 - "N_100130__F_100282" - optional - "N_100130__F_100283" - optional - N_100130__F_100284 - N_100130__F_100285 - "N_100130__F_100286" - optional - N_100130__F_100287 - N_100130__F_100288 - "N_100130__F_100289" - optional - N_100130__F_100290 - N_100130__F_100291 - N_100130__F_100292 - N_100130__F_100293 - N_100130__F_100294 - N_100130__F_100295 - N_100130__F_100296 - "N_100130__F_100297" - optional - N_100130__F_100298 - N_100130__F_100299 - "N_100300__F_100301" - mandatory - "N_100300__F_100302" - alternative - "N_100300__F_100303" - alternative - "N_100300__F_100304" - alternative - "N_100300__F_100305" - alternative - N_100300__F_100306 - N_100300__F_100307 - "N_100300__F_100308" - alternative - N_100300__F_100309 - N_100300__F_100310 - "N_100300__F_100311" - alternative - N_100300__F_100312 - N_100300__F_100313 - "N_100300__F_100314" - alternative - N_100300__F_100315 - N_100300__F_100316 - N_100300__F_100317 - N_100300__F_100318 - N_100300__F_100319 - N_100300__F_100320 - N_100300__F_100321 - N_100300__F_100322 - "N_100300__F_100323" - alternative - N_100300__F_100324 - "N_100300__F_100325" - mandatory - "N_100300__F_100325_xor" {abstract} - optional - N_100300__F_100326 - "N_100300__F_100327" - alternative - N_100300__F_100328 - N_100300__F_100329 - "N_100300__F_100330" - optional - N_100300__F_100331 - "N_100300__F_100332" - alternative - N_100300__F_100333 - N_100300__F_100334 - N_100300__F_100335 - "N_100300__F_100336" - alternative - N_100300__F_100337 - N_100300__F_100338 - N_100300__F_100339 - "N_100300__F_100340" - alternative - N_100300__F_100341 - N_100300__F_100342 - "N_100300__F_100343" - alternative - N_100300__F_100344 - N_100300__F_100345 - "N_100300__F_100346" - mandatory - "N_100300__F_100346_or" {abstract} - or - N_100300__F_100347 - N_100300__F_100348 - - optional - N_100300__F_100349 - - optional - "N_100300__F_100350" - alternative - N_100300__F_100351 - N_100300__F_100352 - "N_100353__F_100354" - mandatory - "N_100353__F_100358" - optional - N_100353__F_100359 - N_100353__F_100360 - N_100353__F_100361 - N_100353__F_100362 - N_100353__F_100363 - N_100353__F_100364 - N_100353__F_100365 - "N_100353__F_100366" - optional - N_100353__F_100367 - N_100353__F_100368 - N_100353__F_100369 - "N_100353__F_100370" - or - N_100353__F_100371 - N_100353__F_100372 - N_100353__F_100373 - N_100353__F_100374 - N_100353__F_100375 - N_100353__F_100376 - N_100353__F_100377 - N_100353__F_100378 - N_100353__F_100379 - "N_100353__F_100380" - or - N_100353__F_100381 - N_100353__F_100382 - N_100353__F_100383 - N_100353__F_100384 - N_100353__F_100385 - "N_100353__F_100386" - optional - N_100353__F_100387 - N_100353__F_100388 - N_100353__F_100389 - "N_100353__F_100390" - optional - "N_100353__F_100391" - or - N_100353__F_100392 - N_100353__F_100393 - "N_100353__F_100394" - or - N_100353__F_100395 - N_100353__F_100396 - "N_100353__F_100397" - or - N_100353__F_100398 - N_100353__F_100399 - "N_100353__F_100400" - or - N_100353__F_100401 - N_100353__F_100402 - N_100353__F_100403 - N_100353__F_100404 - "N_100353__F_100405" - optional - N_100353__F_100406 - "N_100353__F_100407" - optional - N_100353__F_100408 - N_100353__F_100409 - N_100353__F_100410 - N_100353__F_100411 - N_100353__F_100412 - "N_100353__F_100413" - or - N_100353__F_100414 - N_100353__F_100415 - N_100353__F_100416 - N_100353__F_100417 - N_100353__F_100418 - N_100353__F_100419 - N_100353__F_100420 - "N_100353__F_100421" - optional - N_100353__F_100422 - N_100353__F_100423 - N_100353__F_100424 - N_100353__F_100425 - N_100353__F_100426 - N_100353__F_100427 - N_100353__F_100428 - N_100353__F_100429 - N_100353__F_100430 - N_100353__F_100431 - N_100353__F_100432 - N_100353__F_100433 - N_100353__F_100434 - N_100353__F_100435 - N_100353__F_100436 - N_100353__F_100437 - N_100353__F_100438 - "N_100353__F_100439" - optional - N_100353__F_100440 - N_100353__F_100441 - N_100353__F_100442 - N_100353__F_100443 - "N_100353__F_100444" - optional - N_100353__F_100445 - "N_100353__F_100446" - optional - "N_100353__F_100447" - or - N_100353__F_100448 - N_100353__F_100449 - N_100353__F_100450 - N_100353__F_100451 - N_100353__F_100452 - N_100353__F_100453 - "N_100353__F_100454" - optional - N_100353__F_100455 - "N_100353__F_100456" - or - N_100353__F_100457 - N_100353__F_100458 - N_100353__F_100459 - N_100353__F_100460 - N_100353__F_100461 - "N_100462__F_100463" - alternative - N_100462__F_100464 - N_100462__F_100465 - N_100462__F_100466 - - optional - "N_100353__F_100355" - alternative - N_100353__F_100356 - N_100353__F_100357 - "N_100000__F_100467" - mandatory - "N_100000__F_100468" - mandatory - "N_100469__F_100470" - optional - "N_100469__I_100473_i_F_100471" - alternative - N_100469__I_100473_i_F_100474 - N_100469__I_100473_i_F_100477 - N_100469__I_100473_i_F_100480 - N_100469__I_100473_i_F_100483 - N_100469__I_100473_i_F_100486 - N_100469__I_100473_i_F_100489 - "N_100469__I_100494_i_F_100492" - mandatory - "N_100469__I_100494_i_F_100495" - or - N_100469__I_100494_i_F_100498 - N_100469__I_100494_i_F_100501 - "N_100469__I_100506_i_F_100504" - mandatory - "N_100469__I_100506_i_F_100507" - or - N_100469__I_100506_i_F_100510 - N_100469__I_100506_i_F_100513 - "N_100469__I_100518_i_F_100516" - mandatory - "N_100469__I_100518_i_F_100519" - or - N_100469__I_100518_i_F_100522 - N_100469__I_100518_i_F_100525 - "N_100469__I_100530_i_F_100528" - mandatory - "N_100469__I_100530_i_F_100531" - or - N_100469__I_100530_i_F_100534 - N_100469__I_100530_i_F_100537 - "N_100469__I_100542_i_F_100540" - mandatory - "N_100469__I_100542_i_F_100543" - or - N_100469__I_100542_i_F_100546 - N_100469__I_100542_i_F_100549 - "N_100469__I_100554_i_F_100552" - mandatory - "N_100469__I_100554_i_F_100555" - or - N_100469__I_100554_i_F_100558 - N_100469__I_100554_i_F_100561 - "N_100469__I_100566_i_F_100564" - mandatory - "N_100469__I_100566_i_F_100567" - or - N_100469__I_100566_i_F_100570 - N_100469__I_100566_i_F_100573 - "N_100576__F_100577" - mandatory - "N_100576__F_100578" - alternative - N_100576__F_100579 - N_100576__F_100580 - N_100576__F_100581 - N_100576__F_100582 - N_100576__F_100583 - N_100576__F_100584 - N_100576__F_100585 - N_100576__F_100586 - N_100576__F_100587 - "N_100576__F_100588" - mandatory - "N_100576__F_100589" - alternative - N_100576__F_100590 - N_100576__F_100591 - "N_100576__F_100592" - alternative - N_100576__F_100593 - N_100576__F_100594 - "N_100576__F_100595" - alternative - N_100576__F_100596 - N_100576__F_100597 - N_100576__F_100598 - "N_100576__F_100599" - alternative - N_100576__F_100600 - N_100576__F_100601 - N_100576__F_100602 - "N_100576__F_100603" - alternative - N_100576__F_100604 - N_100576__F_100605 - "N_100469__I_100608_i_F_100606" - mandatory - "N_100469__I_100608_i_F_100609" - or - N_100469__I_100608_i_F_100612 - N_100469__I_100608_i_F_100615 - "N_100618__F_100619" - optional - "N_100618__F_100620" - mandatory - "N_100618__F_100621" - alternative - N_100618__I_100624_i_F_100622 - N_100618__F_100625 - "N_100618__F_100626" - mandatory - "N_100618__I_100629_i_F_100627" - alternative - N_100618__I_100629_i_F_100630 - N_100618__I_100629_i_F_100633 - N_100618__I_100629_i_F_100636 - N_100618__I_100629_i_F_100639 - N_100618__I_100629_i_F_100642 - N_100618__I_100629_i_F_100645 - "N_100618__F_100648" - mandatory - "N_100618__F_100649" - or - "N_100618__I_100652_i_F_100650" - alternative - N_100618__I_100652_i_F_100653 - N_100618__I_100652_i_F_100656 - N_100618__I_100652_i_F_100659 - N_100618__I_100652_i_F_100662 - N_100618__I_100652_i_F_100665 - N_100618__I_100652_i_F_100668 - N_100618__I_100673_i_F_100671 - "N_100618__F_100674" - mandatory - "N_100618__I_100677_i_F_100675" - alternative - N_100618__I_100677_i_F_100678 - N_100618__I_100677_i_F_100681 - N_100618__I_100677_i_F_100684 - N_100618__I_100677_i_F_100687 - N_100618__I_100677_i_F_100690 - N_100618__I_100677_i_F_100693 - - optional - N_100618__F_100696 - N_100618__F_100697 - N_100618__F_100698 - N_100618__F_100699 - N_100618__F_100700 - N_100618__F_100701 - N_100618__F_100702 - N_100618__F_100703 - N_100618__F_100704 - N_100618__F_100705 - N_100618__F_100706 - N_100618__F_100707 - N_100618__F_100708 - N_100618__F_100709 - "N_100618__F_100710" - mandatory - "N_100618__I_100713_i_F_100711" - alternative - N_100618__I_100713_i_F_100714 - N_100618__I_100713_i_F_100717 - N_100618__I_100713_i_F_100720 - N_100618__I_100713_i_F_100723 - N_100618__I_100713_i_F_100726 - N_100618__I_100713_i_F_100729 - "N_100618__F_100732" - mandatory - "N_100618__I_100735_i_F_100733" - alternative - N_100618__I_100735_i_F_100736 - N_100618__I_100735_i_F_100739 - N_100618__I_100735_i_F_100742 - N_100618__I_100735_i_F_100745 - N_100618__I_100735_i_F_100748 - N_100618__I_100735_i_F_100751 - - optional - N_100618__F_100754 - N_100618__F_100755 - N_100618__F_100756 - N_100618__F_100757 - N_100618__F_100758 - "N_100618__F_100759" - mandatory - "N_100618__I_100762_i_F_100760" - alternative - N_100618__I_100762_i_F_100763 - N_100618__I_100762_i_F_100766 - N_100618__I_100762_i_F_100769 - N_100618__I_100762_i_F_100772 - N_100618__I_100762_i_F_100775 - N_100618__I_100762_i_F_100778 - - optional - N_100618__F_100781 - N_100618__F_100782 - N_100618__F_100783 - N_100618__F_100784 - N_100618__F_100785 - N_100618__F_100786 - N_100618__F_100787 - N_100618__F_100788 - N_100618__F_100789 - "N_100618__F_100790" - mandatory - "N_100618__I_100793_i_F_100791" - alternative - N_100618__I_100793_i_F_100794 - N_100618__I_100793_i_F_100797 - N_100618__I_100793_i_F_100800 - N_100618__I_100793_i_F_100803 - N_100618__I_100793_i_F_100806 - N_100618__I_100793_i_F_100809 - - optional - N_100618__F_100812 - N_100618__F_100813 - N_100618__F_100814 - N_100618__F_100815 - N_100618__F_100816 - N_100618__F_100817 - N_100618__F_100818 - N_100618__F_100819 - "N_100618__F_100820" - mandatory - "N_100618__I_100823_i_F_100821" - alternative - N_100618__I_100823_i_F_100824 - N_100618__I_100823_i_F_100827 - N_100618__I_100823_i_F_100830 - N_100618__I_100823_i_F_100833 - N_100618__I_100823_i_F_100836 - N_100618__I_100823_i_F_100839 - - optional - N_100618__F_100842 - N_100618__F_100843 - "N_100618__F_100844" - mandatory - "N_100618__I_100847_i_F_100845" - alternative - N_100618__I_100847_i_F_100848 - N_100618__I_100847_i_F_100851 - N_100618__I_100847_i_F_100854 - N_100618__I_100847_i_F_100857 - N_100618__I_100847_i_F_100860 - N_100618__I_100847_i_F_100863 - - optional - N_100618__F_100866 - N_100618__F_100867 - N_100618__F_100868 - "N_100618__F_100869" - mandatory - N_100618__I_100872_i_F_100870 - "N_100000__F_100873" - mandatory - "N_100000__F_100874" - mandatory - "N_100000__I_100877_i_F_100875" - mandatory - "N_100000__I_100877_i_F_100878" - alternative - N_100000__I_100877_i_F_100881 - N_100000__I_100877_i_F_100884 - N_100000__I_100877_i_F_100887 - N_100000__I_100877_i_F_100890 - N_100000__I_100877_i_F_100893 - N_100000__I_100877_i_F_100896 - N_100000__I_100877_i_F_100899 - N_100000__I_100877_i_F_100902 - N_100000__I_100877_i_F_100905 - N_100000__I_100877_i_F_100908 - "N_100000__I_100877_i_F_100911" - alternative - N_100000__I_100877_i_F_100914 - "N_100000__I_100877_i_F_100917" - alternative - N_100000__I_100877_i_F_100920 - N_100000__I_100877_i_F_100923 - N_100000__I_100877_i_F_100926 - N_100000__I_100877_i_F_100929 - N_100000__I_100877_i_F_100932 - N_100000__I_100877_i_F_100935 - N_100000__I_100877_i_F_100938 - N_100000__I_100877_i_F_100941 - "N_100000__I_100877_i_F_100944" - alternative - N_100000__I_100877_i_F_100947 - N_100000__I_100877_i_F_100950 - "N_100000__I_100877_i_F_100962" - alternative - N_100000__I_100877_i_F_100965 - N_100000__I_100877_i_F_100968 - N_100000__I_100877_i_F_100971 - - optional - N_100000__I_100877_i_F_100953 - N_100000__I_100877_i_F_100956 - N_100000__I_100877_i_F_100959 - "N_100000__I_101075_i_F_101073" - mandatory - "N_100000__I_101075_i_F_101076" - alternative - N_100000__I_101075_i_F_101079 - N_100000__I_101075_i_F_101082 - N_100000__I_101075_i_F_101085 - N_100000__I_101075_i_F_101088 - N_100000__I_101075_i_F_101091 - N_100000__I_101075_i_F_101094 - N_100000__I_101075_i_F_101097 - N_100000__I_101075_i_F_101100 - N_100000__I_101075_i_F_101103 - N_100000__I_101075_i_F_101106 - "N_100000__I_101075_i_F_101109" - alternative - N_100000__I_101075_i_F_101112 - "N_100000__I_101075_i_F_101115" - alternative - N_100000__I_101075_i_F_101118 - N_100000__I_101075_i_F_101121 - N_100000__I_101075_i_F_101124 - N_100000__I_101075_i_F_101127 - N_100000__I_101075_i_F_101130 - N_100000__I_101075_i_F_101133 - N_100000__I_101075_i_F_101136 - N_100000__I_101075_i_F_101139 - "N_100000__I_101075_i_F_101142" - alternative - N_100000__I_101075_i_F_101145 - N_100000__I_101075_i_F_101148 - "N_100000__I_101075_i_F_101160" - alternative - N_100000__I_101075_i_F_101163 - N_100000__I_101075_i_F_101166 - N_100000__I_101075_i_F_101169 - - optional - N_100000__I_101075_i_F_101151 - N_100000__I_101075_i_F_101154 - N_100000__I_101075_i_F_101157 - - optional - "N_100000__I_100976_i_F_100974" - mandatory - "N_100000__I_100976_i_F_100977" - alternative - N_100000__I_100976_i_F_100980 - N_100000__I_100976_i_F_100983 - N_100000__I_100976_i_F_100986 - N_100000__I_100976_i_F_100989 - N_100000__I_100976_i_F_100992 - N_100000__I_100976_i_F_100995 - N_100000__I_100976_i_F_100998 - N_100000__I_100976_i_F_101001 - N_100000__I_100976_i_F_101004 - N_100000__I_100976_i_F_101007 - "N_100000__I_100976_i_F_101010" - alternative - N_100000__I_100976_i_F_101013 - "N_100000__I_100976_i_F_101016" - alternative - N_100000__I_100976_i_F_101019 - N_100000__I_100976_i_F_101022 - N_100000__I_100976_i_F_101025 - N_100000__I_100976_i_F_101028 - N_100000__I_100976_i_F_101031 - N_100000__I_100976_i_F_101034 - N_100000__I_100976_i_F_101037 - N_100000__I_100976_i_F_101040 - "N_100000__I_100976_i_F_101043" - alternative - N_100000__I_100976_i_F_101046 - N_100000__I_100976_i_F_101049 - "N_100000__I_100976_i_F_101061" - alternative - N_100000__I_100976_i_F_101064 - N_100000__I_100976_i_F_101067 - N_100000__I_100976_i_F_101070 - - optional - N_100000__I_100976_i_F_101052 - N_100000__I_100976_i_F_101055 - N_100000__I_100976_i_F_101058 - "N_100000__I_101174_i_F_101172" - mandatory - "N_100000__I_101174_i_F_101175" - alternative - N_100000__I_101174_i_F_101178 - N_100000__I_101174_i_F_101181 - N_100000__I_101174_i_F_101184 - N_100000__I_101174_i_F_101187 - N_100000__I_101174_i_F_101190 - N_100000__I_101174_i_F_101193 - N_100000__I_101174_i_F_101196 - N_100000__I_101174_i_F_101199 - N_100000__I_101174_i_F_101202 - N_100000__I_101174_i_F_101205 - "N_100000__I_101174_i_F_101208" - alternative - N_100000__I_101174_i_F_101211 - "N_100000__I_101174_i_F_101214" - alternative - N_100000__I_101174_i_F_101217 - N_100000__I_101174_i_F_101220 - N_100000__I_101174_i_F_101223 - N_100000__I_101174_i_F_101226 - N_100000__I_101174_i_F_101229 - N_100000__I_101174_i_F_101232 - N_100000__I_101174_i_F_101235 - N_100000__I_101174_i_F_101238 - "N_100000__I_101174_i_F_101241" - alternative - N_100000__I_101174_i_F_101244 - N_100000__I_101174_i_F_101247 - "N_100000__I_101174_i_F_101259" - alternative - N_100000__I_101174_i_F_101262 - N_100000__I_101174_i_F_101265 - N_100000__I_101174_i_F_101268 - - optional - N_100000__I_101174_i_F_101250 - N_100000__I_101174_i_F_101253 - N_100000__I_101174_i_F_101256 - N_100000__F_101271 - N_100000__F_101272 - - optional - "N_100000__F_101273" - mandatory - "N_100000__F_101274" - alternative - N_100000__F_101275 - N_100000__F_101276 - N_100000__F_101277 - N_100000__F_101278 - N_100000__F_101279 - N_100000__F_101280 - N_100000__F_101281 - N_100000__F_101282 - "N_100000__I_101285_i_F_101283" - mandatory - "N_100000__I_101285_i_F_101286" - alternative - N_100000__I_101285_i_F_101289 - N_100000__I_101285_i_F_101292 - "N_100000__I_101285_i_F_101295" - optional - N_100000__I_101285_i_F_101298 - "N_100000__I_101285_i_F_101301" - alternative - N_100000__I_101285_i_F_101304 - N_100000__I_101285_i_F_101307 - "N_100000__I_101285_i_F_101310" - optional - N_100000__I_101285_i_F_101313 - "N_100000__I_101285_i_F_101316" - mandatory - "N_100000__I_101285_i_F_101319" - alternative - N_100000__I_101285_i_F_101322 - N_100000__I_101285_i_F_101325 - N_100000__I_101285_i_F_101328 - N_100000__I_101285_i_F_101331 - "N_100000__I_101285_i_F_101316_xor" {abstract} - alternative - "N_100000__I_101285_i_F_101334" - alternative - N_100000__I_101285_i_F_101337 - N_100000__I_101285_i_F_101340 - "N_100000__I_101285_i_F_101343" - alternative - N_100000__I_101285_i_F_101346 - N_100000__I_101285_i_F_101349 - N_100000__I_101285_i_F_101352 - N_100000__I_101285_i_F_101355 - N_100000__I_101285_i_F_101358 - "N_100000__I_101285_i_F_101361" - alternative - N_100000__I_101285_i_F_101364 - N_100000__I_101285_i_F_101367 - N_100000__I_101285_i_F_101370 - N_100000__I_101285_i_F_101373 - N_100000__I_101285_i_F_101376 - N_100000__I_101285_i_F_101379 - N_100000__I_101285_i_F_101382 - N_100000__I_101285_i_F_101385 - "N_100000__I_101285_i_F_101388" - alternative - N_100000__I_101285_i_F_101391 - N_100000__I_101285_i_F_101394 - N_100000__I_101285_i_F_101397 - N_100000__I_101285_i_F_101400 - - optional - "N_100000__I_101405_i_F_101403" - mandatory - "N_100000__I_101405_i_F_101406" - alternative - N_100000__I_101405_i_F_101409 - N_100000__I_101405_i_F_101412 - "N_100000__I_101405_i_F_101415" - optional - N_100000__I_101405_i_F_101418 - "N_100000__I_101405_i_F_101421" - alternative - N_100000__I_101405_i_F_101424 - N_100000__I_101405_i_F_101427 - "N_100000__I_101405_i_F_101430" - optional - N_100000__I_101405_i_F_101433 - "N_100000__I_101405_i_F_101436" - mandatory - "N_100000__I_101405_i_F_101439" - alternative - N_100000__I_101405_i_F_101442 - N_100000__I_101405_i_F_101445 - N_100000__I_101405_i_F_101448 - N_100000__I_101405_i_F_101451 - "N_100000__I_101405_i_F_101436_xor" {abstract} - alternative - "N_100000__I_101405_i_F_101454" - alternative - N_100000__I_101405_i_F_101457 - N_100000__I_101405_i_F_101460 - "N_100000__I_101405_i_F_101463" - alternative - N_100000__I_101405_i_F_101466 - N_100000__I_101405_i_F_101469 - N_100000__I_101405_i_F_101472 - N_100000__I_101405_i_F_101475 - N_100000__I_101405_i_F_101478 - "N_100000__I_101405_i_F_101481" - alternative - N_100000__I_101405_i_F_101484 - N_100000__I_101405_i_F_101487 - N_100000__I_101405_i_F_101490 - N_100000__I_101405_i_F_101493 - N_100000__I_101405_i_F_101496 - N_100000__I_101405_i_F_101499 - N_100000__I_101405_i_F_101502 - N_100000__I_101405_i_F_101505 - "N_100000__I_101405_i_F_101508" - alternative - N_100000__I_101405_i_F_101511 - N_100000__I_101405_i_F_101514 - N_100000__I_101405_i_F_101517 - N_100000__I_101405_i_F_101520 - "N_100000__I_101525_i_F_101523" - mandatory - "N_100000__I_101525_i_F_101526" - alternative - N_100000__I_101525_i_F_101529 - N_100000__I_101525_i_F_101532 - "N_100000__I_101525_i_F_101535" - optional - N_100000__I_101525_i_F_101538 - "N_100000__I_101525_i_F_101541" - alternative - N_100000__I_101525_i_F_101544 - N_100000__I_101525_i_F_101547 - "N_100000__I_101525_i_F_101550" - optional - N_100000__I_101525_i_F_101553 - "N_100000__I_101525_i_F_101556" - mandatory - "N_100000__I_101525_i_F_101559" - alternative - N_100000__I_101525_i_F_101562 - N_100000__I_101525_i_F_101565 - N_100000__I_101525_i_F_101568 - N_100000__I_101525_i_F_101571 - "N_100000__I_101525_i_F_101556_xor" {abstract} - alternative - "N_100000__I_101525_i_F_101574" - alternative - N_100000__I_101525_i_F_101577 - N_100000__I_101525_i_F_101580 - "N_100000__I_101525_i_F_101583" - alternative - N_100000__I_101525_i_F_101586 - N_100000__I_101525_i_F_101589 - N_100000__I_101525_i_F_101592 - N_100000__I_101525_i_F_101595 - N_100000__I_101525_i_F_101598 - "N_100000__I_101525_i_F_101601" - alternative - N_100000__I_101525_i_F_101604 - N_100000__I_101525_i_F_101607 - N_100000__I_101525_i_F_101610 - N_100000__I_101525_i_F_101613 - N_100000__I_101525_i_F_101616 - N_100000__I_101525_i_F_101619 - N_100000__I_101525_i_F_101622 - N_100000__I_101525_i_F_101625 - "N_100000__I_101525_i_F_101628" - alternative - N_100000__I_101525_i_F_101631 - N_100000__I_101525_i_F_101634 - N_100000__I_101525_i_F_101637 - N_100000__I_101525_i_F_101640 - "N_100000__I_101645_i_F_101643" - mandatory - "N_100000__I_101645_i_F_101646" - alternative - N_100000__I_101645_i_F_101649 - N_100000__I_101645_i_F_101652 - "N_100000__I_101645_i_F_101655" - optional - N_100000__I_101645_i_F_101658 - "N_100000__I_101645_i_F_101661" - alternative - N_100000__I_101645_i_F_101664 - N_100000__I_101645_i_F_101667 - "N_100000__I_101645_i_F_101670" - optional - N_100000__I_101645_i_F_101673 - "N_100000__I_101645_i_F_101676" - mandatory - "N_100000__I_101645_i_F_101679" - alternative - N_100000__I_101645_i_F_101682 - N_100000__I_101645_i_F_101685 - N_100000__I_101645_i_F_101688 - N_100000__I_101645_i_F_101691 - "N_100000__I_101645_i_F_101676_xor" {abstract} - alternative - "N_100000__I_101645_i_F_101694" - alternative - N_100000__I_101645_i_F_101697 - N_100000__I_101645_i_F_101700 - "N_100000__I_101645_i_F_101703" - alternative - N_100000__I_101645_i_F_101706 - N_100000__I_101645_i_F_101709 - N_100000__I_101645_i_F_101712 - N_100000__I_101645_i_F_101715 - N_100000__I_101645_i_F_101718 - "N_100000__I_101645_i_F_101721" - alternative - N_100000__I_101645_i_F_101724 - N_100000__I_101645_i_F_101727 - N_100000__I_101645_i_F_101730 - N_100000__I_101645_i_F_101733 - N_100000__I_101645_i_F_101736 - N_100000__I_101645_i_F_101739 - N_100000__I_101645_i_F_101742 - N_100000__I_101645_i_F_101745 - "N_100000__I_101645_i_F_101748" - alternative - N_100000__I_101645_i_F_101751 - N_100000__I_101645_i_F_101754 - N_100000__I_101645_i_F_101757 - N_100000__I_101645_i_F_101760 - N_100000__F_101763 - "N_101764__F_101765" - mandatory - "N_101764__F_101766" - alternative - N_101764__F_101767 - N_101764__F_101768 - N_101764__F_101769 - N_101764__F_101770 - N_101764__F_101771 - N_101764__F_101772 - N_101764__F_101773 - N_101764__F_101774 - N_101764__F_101775 - N_101764__F_101776 - N_101764__F_101777 - N_101764__F_101778 - N_101764__F_101779 - N_101764__F_101780 - N_101764__F_101781 - N_101764__F_101782 - "N_101764__F_101783" - alternative - "N_101764__F_101784" - mandatory - "N_101764__F_101784_xor" {abstract} - optional - "N_101764__F_101785" - alternative - N_101764__F_101786 - N_101764__F_101787 - N_101764__F_101788 - N_101764__F_101789 - N_101764__F_101790 - N_101764__F_101791 - - optional - N_101764__F_101792 - "N_101764__F_101793" - alternative - "N_101764__F_101794" - mandatory - "N_101764__F_101795" - alternative - N_101764__F_101796 - N_101764__F_101797 - "N_101764__F_101798" - mandatory - "N_101764__F_101799" - alternative - N_101764__F_101800 - N_101764__F_101801 - N_101764__F_101802 - N_101764__F_101803 - N_101764__F_101804 - N_101764__F_101805 - N_101764__F_101806 - "N_101764__F_101807" - mandatory - "N_101764__F_101808" - optional - N_101764__F_101809 - "N_101764__F_101810" - alternative - "N_101764__F_101811" - alternative - N_101764__F_101812 - N_101764__F_101813 - "N_101764__I_101816_i_F_101814" - alternative - N_101764__I_101816_i_F_101817 - N_101764__I_101816_i_F_101820 - N_101764__I_101816_i_F_101823 - N_101764__I_101816_i_F_101826 - N_101764__I_101816_i_F_101829 - N_101764__I_101816_i_F_101832 - "N_101764__F_101835" - or - "N_101764__F_101836" - mandatory - "N_101764__I_101839_i_F_101837" - or - N_101764__I_101839_i_F_101840 - N_101764__I_101839_i_F_101843 - "N_101764__F_101846" - mandatory - "N_101764__I_101849_i_F_101847" - or - N_101764__I_101849_i_F_101850 - N_101764__I_101849_i_F_101853 - "N_101764__F_101856" - mandatory - "N_101764__I_101859_i_F_101857" - or - N_101764__I_101859_i_F_101860 - N_101764__I_101859_i_F_101863 - "N_101764__F_101866" - or - "N_101764__F_101867" - mandatory - "N_101764__I_101870_i_F_101868" - or - N_101764__I_101870_i_F_101871 - N_101764__I_101870_i_F_101874 - N_101764__I_101870_i_F_101877 - "N_101764__F_101880" - mandatory - "N_101764__I_101883_i_F_101881" - or - N_101764__I_101883_i_F_101884 - N_101764__I_101883_i_F_101887 - N_101764__I_101883_i_F_101890 - "N_101764__F_101893" - mandatory - "N_101764__I_101896_i_F_101894" - or - N_101764__I_101896_i_F_101897 - N_101764__I_101896_i_F_101900 - N_101764__I_101896_i_F_101903 - "N_101906__F_101907" - mandatory - "N_101906__F_101908" - alternative - N_101906__F_101909 - N_101906__F_101910 - N_101906__F_101911 - "N_101906__F_101912" - alternative - N_101906__F_101913 - N_101906__F_101914 - "N_101906__F_101915" - alternative - N_101906__F_101916 - N_101906__F_101917 - N_101906__F_101918 - "N_101906__F_101919" - alternative - N_101906__F_101920 - N_101906__F_101921 - "N_101906__F_101922" - alternative - "N_101906__F_101923" - optional - "N_101906__F_101924" - optional - N_101906__F_101925 - N_101906__F_101926 - - optional - "N_101906__F_101927" - optional - N_101906__F_101928 - "N_101906__F_101929" - or - N_101906__F_101930 - N_101906__F_101931 - "N_101932__F_101933" - mandatory - "N_101932__F_101934" - alternative - N_101932__F_101935 - N_101932__F_101936 - N_101932__F_101937 - N_101932__F_101938 - N_101932__F_101939 - N_101932__F_101940 - N_101932__F_101941 - N_101932__F_101942 - N_101932__F_101943 - N_101932__F_101944 - N_101932__F_101945 - "N_101932__F_101946" - alternative - "N_101932__F_101947" - or - N_101932__F_101948 - N_101932__F_101949 - N_101932__F_101950 - N_101932__F_101951 - "N_101932__F_101952" - optional - N_101932__F_101953 - "N_101932__F_101954" - or - N_101932__F_101955 - N_101932__F_101956 - N_101932__F_101957 - N_101932__F_101958 - N_101932__F_101959 - N_101932__F_101960 - N_101932__F_101961 - N_101932__F_101962 - N_101932__F_101963 - "N_101932__F_101964" - mandatory - "N_101932__I_101967_i_F_101965" - alternative - N_101932__I_101967_i_F_101968 - N_101932__I_101967_i_F_101971 - N_101932__I_101967_i_F_101974 - N_101932__I_101967_i_F_101977 - N_101932__I_101967_i_F_101980 - N_101932__I_101967_i_F_101983 - "N_101932__F_101990" - mandatory - "N_101932__I_101993_i_F_101991" - or - N_101932__I_101993_i_F_101994 - N_101932__I_101993_i_F_101997 - N_101932__I_101993_i_F_102000 - - optional - "N_101932__F_101986" - optional - "N_101932__F_101987" - alternative - N_101932__F_101988 - N_101932__F_101989 - N_100000__F_102003 - "N_102004__F_102005" - mandatory - "N_102004__F_102006" - alternative - N_102004__F_102007 - N_102004__F_102008 - N_102004__F_102009 - "N_102004__F_102010" - mandatory - "N_102004__F_102011" - alternative - N_102004__F_102012 - "N_102004__F_102013" - optional - "N_102004__F_102014" - optional - N_102004__F_102015 - "N_102004__F_102016" - optional - N_102004__F_102017 - "N_102004__F_102018" - optional - "N_102004__F_102019" - optional - N_102004__F_102020 - - optional - "N_102004__F_102021" - optional - N_102004__F_102022 - "N_102004__F_102023" - alternative - N_102004__F_102024 - N_102004__F_102025 - "N_102026__F_102027" - mandatory - "N_102026__F_102029" - optional - N_102026__F_102030 - N_102026__F_102031 - N_102026__F_102032 - "N_102026__F_102038" - optional - N_102026__F_102039 - N_102026__F_102040 - N_102026__F_102041 - - optional - N_102026__F_102028 - "N_102026__F_102033" - mandatory - "N_102026__F_102033_xor" {abstract} - alternative - N_102026__F_102034 - N_102026__F_102035 - N_102026__F_102036 - - optional - N_102026__F_102037 - "N_100000__F_102042" - mandatory - "N_102043__F_102044" - mandatory - "N_102043__F_102044_or" {abstract} - optional - "N_102043__F_102050" - mandatory - "N_102043__I_102053_i_F_102051" - alternative - N_102043__I_102053_i_F_102054 - N_102043__I_102053_i_F_102057 - N_102043__I_102053_i_F_102060 - N_102043__I_102053_i_F_102063 - N_102043__I_102053_i_F_102066 - N_102043__I_102053_i_F_102069 - "N_102043__I_102076_i_F_102074" - mandatory - "N_102043__I_102076_i_F_102077" - alternative - N_102043__I_102076_i_F_102080 - N_102043__I_102076_i_F_102083 - "N_102043__I_102088_i_F_102086" - mandatory - "N_102043__I_102088_i_F_102089" - alternative - N_102043__I_102088_i_F_102092 - N_102043__I_102088_i_F_102095 - - optional - N_102043__F_102072 - N_102043__F_102073 - "N_102043__I_102100_i_F_102098" - mandatory - "N_102043__I_102100_i_F_102101" - alternative - N_102043__I_102100_i_F_102104 - N_102043__I_102100_i_F_102107 - "N_102043__I_102112_i_F_102110" - mandatory - "N_102043__I_102112_i_F_102113" - alternative - N_102043__I_102112_i_F_102116 - N_102043__I_102112_i_F_102119 - "N_102043__I_102124_i_F_102122" - mandatory - "N_102043__I_102124_i_F_102125" - alternative - N_102043__I_102124_i_F_102128 - N_102043__I_102124_i_F_102131 - "N_102043__I_102136_i_F_102134" - mandatory - "N_102043__I_102136_i_F_102137" - alternative - N_102043__I_102136_i_F_102140 - N_102043__I_102136_i_F_102143 - "N_102043__I_102148_i_F_102146" - mandatory - "N_102043__I_102148_i_F_102149" - alternative - N_102043__I_102148_i_F_102152 - N_102043__I_102148_i_F_102155 - "N_102043__I_102160_i_F_102158" - mandatory - "N_102043__I_102160_i_F_102161" - alternative - N_102043__I_102160_i_F_102164 - N_102043__I_102160_i_F_102167 - "N_102043__I_102172_i_F_102170" - mandatory - "N_102043__I_102172_i_F_102173" - alternative - N_102043__I_102172_i_F_102176 - N_102043__I_102172_i_F_102179 - "N_102043__I_102184_i_F_102182" - mandatory - "N_102043__I_102184_i_F_102185" - alternative - N_102043__I_102184_i_F_102188 - N_102043__I_102184_i_F_102191 - - optional - "N_102043__F_102045" - optional - N_102043__F_102046 - N_102043__F_102047 - N_102043__F_102048 - N_102043__F_102049 - "N_102043__F_102194" - mandatory - "N_102043__I_102197_i_F_102195" - mandatory - "N_102043__I_102197_i_F_102198" - alternative - N_102043__I_102197_i_F_102201 - N_102043__I_102197_i_F_102204 - - optional - N_102043__F_102207 - "N_102043__F_102208" - mandatory - "N_102043__I_102211_i_F_102209" - alternative - N_102043__I_102211_i_F_102212 - N_102043__I_102211_i_F_102215 - N_102043__I_102211_i_F_102218 - N_102043__I_102211_i_F_102221 - N_102043__I_102211_i_F_102224 - N_102043__I_102211_i_F_102227 - - optional - "N_102043__F_102230" - alternative - N_102043__I_102233_i_F_102231 - N_102043__F_102234 - N_102043__F_102235 - N_102043__F_102236 - "N_102043__F_102237" - mandatory - "N_102043__I_102240_i_F_102238" - alternative - N_102043__I_102240_i_F_102241 - N_102043__I_102240_i_F_102244 - N_102043__I_102240_i_F_102247 - N_102043__I_102240_i_F_102250 - N_102043__I_102240_i_F_102253 - N_102043__I_102240_i_F_102256 - "N_102043__F_102259" - mandatory - "N_102043__I_102262_i_F_102260" - alternative - N_102043__I_102262_i_F_102263 - N_102043__I_102262_i_F_102266 - N_102043__I_102262_i_F_102269 - N_102043__I_102262_i_F_102272 - N_102043__I_102262_i_F_102275 - N_102043__I_102262_i_F_102278 - - optional - N_102043__F_102281 - N_102043__F_102282 - "N_102043__F_102283" - mandatory - "N_102043__I_102286_i_F_102284" - alternative - N_102043__I_102286_i_F_102287 - N_102043__I_102286_i_F_102290 - N_102043__I_102286_i_F_102293 - N_102043__I_102286_i_F_102296 - N_102043__I_102286_i_F_102299 - N_102043__I_102286_i_F_102302 - - optional - N_102043__F_102305 - N_102043__F_102306 - N_102043__F_102307 - N_102043__F_102308 - N_102043__F_102309 - N_102043__F_102310 - "N_102043__F_102311" - mandatory - "N_102043__I_102314_i_F_102312" - alternative - N_102043__I_102314_i_F_102315 - N_102043__I_102314_i_F_102318 - N_102043__I_102314_i_F_102321 - N_102043__I_102314_i_F_102324 - N_102043__I_102314_i_F_102327 - N_102043__I_102314_i_F_102330 - "N_102043__F_102333" - mandatory - "N_102043__I_102336_i_F_102334" - alternative - N_102043__I_102336_i_F_102337 - N_102043__I_102336_i_F_102340 - N_102043__I_102336_i_F_102343 - N_102043__I_102336_i_F_102346 - N_102043__I_102336_i_F_102349 - N_102043__I_102336_i_F_102352 - - optional - N_102043__F_102355 - "N_102043__F_102356" - mandatory - "N_102043__I_102359_i_F_102357" - alternative - N_102043__I_102359_i_F_102360 - N_102043__I_102359_i_F_102363 - N_102043__I_102359_i_F_102366 - N_102043__I_102359_i_F_102369 - N_102043__I_102359_i_F_102372 - N_102043__I_102359_i_F_102375 - - optional - N_102043__F_102378 - N_102043__F_102379 - N_102043__F_102380 - N_102043__F_102381 - "N_100000__F_102382" - mandatory - "N_100000__F_102382_xor" {abstract} - alternative - "N_102383__F_102384" - mandatory - "N_102385__F_102386" - mandatory - "N_102385__F_102405" - mandatory - "N_102385__F_102406" - alternative - N_102385__F_102407 - N_102385__F_102408 - N_102385__F_102409 - N_102385__F_102410 - N_102385__F_102411 - N_102385__F_102412 - N_102385__F_102413 - N_102385__F_102414 - N_102385__F_102415 - N_102385__F_102416 - N_102385__F_102417 - N_102385__F_102418 - "N_102385__F_102419" - alternative - N_102385__F_102420 - N_102385__F_102421 - N_102385__F_102422 - "N_102385__F_102423" - mandatory - "N_102385__F_102424" - mandatory - "N_102385__F_102425" - alternative - N_102385__F_102426 - N_102385__F_102427 - N_102385__F_102428 - N_102385__F_102429 - N_102385__F_102430 - N_102385__F_102431 - N_102385__F_102432 - "N_102385__F_102433" - alternative - N_102385__F_102434 - N_102385__F_102435 - N_102385__F_102436 - N_102385__F_102437 - "N_102385__F_102438" - alternative - N_102385__F_102439 - N_102385__F_102440 - N_102385__F_102441 - N_102385__F_102442 - "N_102385__F_102443" - alternative - N_102385__F_102444 - N_102385__F_102445 - "N_102385__F_102446" - alternative - N_102385__F_102447 - N_102385__F_102448 - N_102385__F_102449 - N_102385__F_102450 - N_102385__F_102451 - "N_102385__F_102452" - alternative - N_102385__F_102453 - N_102385__F_102454 - "N_102385__F_102455" - mandatory - "N_102385__F_102456" - mandatory - "N_102385__F_102456_xor" {abstract} - alternative - N_102385__F_102457 - N_102385__F_102458 - N_102385__F_102459 - N_102385__F_102460 - N_102385__F_102461 - N_102385__F_102462 - N_102385__F_102463 - - optional - N_102385__F_102464 - "N_102385__F_102465" - alternative - N_102385__F_102466 - N_102385__F_102467 - N_102385__F_102468 - "N_102385__F_102469" - alternative - N_102385__F_102470 - N_102385__F_102471 - N_102385__F_102472 - N_102385__F_102473 - N_102385__F_102474 - "N_102385__F_102475" - alternative - N_102385__F_102476 - N_102385__F_102477 - N_102385__F_102478 - N_102385__F_102479 - "N_102385__F_102480" - mandatory - "N_102385__F_102480_xor" {abstract} - alternative - N_102385__F_102481 - N_102385__F_102482 - - optional - "N_102385__F_102483" - alternative - N_102385__F_102484 - N_102385__F_102485 - N_102385__F_102486 - "N_102385__F_102489" - mandatory - "N_102385__F_102490" - alternative - N_102385__F_102491 - N_102385__F_102492 - N_102385__F_102493 - N_102385__F_102494 - N_102385__F_102495 - N_102385__F_102496 - N_102385__F_102497 - N_102385__F_102498 - N_102385__F_102499 - - optional - N_102385__F_102500 - - optional - "N_102385__F_102387" - alternative - N_102385__F_102388 - N_102385__F_102389 - N_102385__F_102390 - N_102385__F_102391 - N_102385__F_102392 - N_102385__F_102393 - N_102385__F_102394 - N_102385__F_102395 - N_102385__F_102396 - N_102385__F_102397 - N_102385__F_102398 - N_102385__F_102399 - N_102385__F_102400 - N_102385__F_102401 - N_102385__F_102402 - N_102385__F_102403 - N_102385__F_102404 - N_102385__F_102487 - N_102385__F_102488 - "N_102383__F_102501" - mandatory - "N_102383__I_102504_i_F_102502" - mandatory - "N_102383__I_102504_i_F_102505" - alternative - N_102383__I_102504_i_F_102508 - N_102383__I_102504_i_F_102511 - N_102383__I_102504_i_F_102514 - N_102383__I_102504_i_F_102517 - N_102383__I_102504_i_F_102520 - N_102383__I_102504_i_F_102523 - N_102383__I_102504_i_F_102526 - N_102383__I_102504_i_F_102529 - N_102383__I_102504_i_F_102532 - N_102383__I_102504_i_F_102535 - N_102383__I_102504_i_F_102538 - N_102383__I_102504_i_F_102541 - N_102383__I_102504_i_F_102544 - N_102383__I_102504_i_F_102547 - N_102383__I_102504_i_F_102550 - N_102383__I_102504_i_F_102553 - N_102383__I_102504_i_F_102556 - N_102383__I_102504_i_F_102559 - N_102383__I_102504_i_F_102562 - N_102383__I_102504_i_F_102565 - "N_102383__I_102504_i_F_102568" - alternative - N_102383__I_102504_i_F_102571 - N_102383__I_102504_i_F_102574 - N_102383__I_102504_i_F_102577 - N_102383__I_102504_i_F_102580 - N_102383__I_102504_i_F_102583 - N_102383__I_102504_i_F_102586 - N_102383__I_102504_i_F_102589 - N_102383__I_102504_i_F_102592 - N_102383__I_102504_i_F_102595 - N_102383__I_102504_i_F_102598 - N_102383__I_102504_i_F_102601 - N_102383__I_102504_i_F_102604 - N_102383__I_102504_i_F_102607 - "N_102383__I_102504_i_F_102610" - alternative - N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102616 - "N_102383__I_102504_i_F_102619" - alternative - N_102383__I_102504_i_F_102622 - N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102628 - "N_102383__I_102504_i_F_102631" - alternative - N_102383__I_102504_i_F_102634 - N_102383__I_102504_i_F_102637 - "N_102383__I_102642_i_F_102640" - mandatory - "N_102383__I_102642_i_F_102643" - alternative - N_102383__I_102642_i_F_102646 - N_102383__I_102642_i_F_102649 - N_102383__I_102642_i_F_102652 - N_102383__I_102642_i_F_102655 - N_102383__I_102642_i_F_102658 - N_102383__I_102642_i_F_102661 - N_102383__I_102642_i_F_102664 - N_102383__I_102642_i_F_102667 - N_102383__I_102642_i_F_102670 - N_102383__I_102642_i_F_102673 - N_102383__I_102642_i_F_102676 - N_102383__I_102642_i_F_102679 - N_102383__I_102642_i_F_102682 - N_102383__I_102642_i_F_102685 - N_102383__I_102642_i_F_102688 - N_102383__I_102642_i_F_102691 - N_102383__I_102642_i_F_102694 - N_102383__I_102642_i_F_102697 - N_102383__I_102642_i_F_102700 - N_102383__I_102642_i_F_102703 - "N_102383__I_102642_i_F_102706" - alternative - N_102383__I_102642_i_F_102709 - N_102383__I_102642_i_F_102712 - N_102383__I_102642_i_F_102715 - N_102383__I_102642_i_F_102718 - N_102383__I_102642_i_F_102721 - N_102383__I_102642_i_F_102724 - N_102383__I_102642_i_F_102727 - N_102383__I_102642_i_F_102730 - N_102383__I_102642_i_F_102733 - N_102383__I_102642_i_F_102736 - N_102383__I_102642_i_F_102739 - N_102383__I_102642_i_F_102742 - N_102383__I_102642_i_F_102745 - "N_102383__I_102642_i_F_102748" - alternative - N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102754 - "N_102383__I_102642_i_F_102757" - alternative - N_102383__I_102642_i_F_102760 - N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102766 - "N_102383__I_102642_i_F_102769" - alternative - N_102383__I_102642_i_F_102772 - N_102383__I_102642_i_F_102775 - "N_102383__F_102778" - mandatory - "N_102383__F_102778_xor" {abstract} - alternative - N_102383__F_102779 - N_102383__F_102780 - N_102383__F_102781 - - optional - N_102383__F_102782 - N_102383__F_102783 - N_102383__F_102784 - N_102383__F_102785 - N_102383__F_102786 - N_102383__F_102787 - "N_102383__F_102788" - mandatory - "N_102383__I_103300_i_F_103298" - mandatory - "N_102383__I_103300_i_F_103346" - mandatory - "N_102383__I_103300_i_F_103364" - alternative - N_102383__I_103300_i_F_103367 - N_102383__I_103300_i_F_103370 - N_102383__I_103300_i_F_103373 - N_102383__I_103300_i_F_103376 - N_102383__I_103300_i_F_103379 - N_102383__I_103300_i_F_103382 - "N_102383__I_103300_i_F_103385" - mandatory - "N_102383__I_103300_i_F_103400" - alternative - N_102383__I_103300_i_F_103403 - N_102383__I_103300_i_F_103406 - "N_102383__I_103300_i_F_103409" - alternative - N_102383__I_103300_i_F_103412 - N_102383__I_103300_i_F_103415 - "N_102383__I_103300_i_F_103418" - alternative - N_102383__I_103300_i_F_103421 - N_102383__I_103300_i_F_103424 - - optional - "N_102383__I_103300_i_F_103388" - alternative - N_102383__I_103300_i_F_103391 - N_102383__I_103300_i_F_103394 - N_102383__I_103300_i_F_103397 - N_102383__I_103300_i_F_103427 - "N_102383__I_103300_i_F_103430" - alternative - N_102383__I_103300_i_F_103433 - N_102383__I_103300_i_F_103436 - "N_102383__I_103300_i_F_103439" - alternative - N_102383__I_103300_i_F_103442 - N_102383__I_103300_i_F_103445 - - optional - "N_102383__I_103300_i_F_103349" - alternative - N_102383__I_103300_i_F_103352 - N_102383__I_103300_i_F_103355 - N_102383__I_103300_i_F_103358 - N_102383__I_103300_i_F_103361 - "N_102383__I_103300_i_F_103448" - alternative - N_102383__I_103300_i_F_103451 - N_102383__I_103300_i_F_103454 - "N_102383__I_103300_i_F_103457" - mandatory - "N_102383__I_103300_i_F_103472" - alternative - N_102383__I_103300_i_F_103475 - N_102383__I_103300_i_F_103478 - N_102383__I_103300_i_F_103481 - N_102383__I_103300_i_F_103484 - "N_102383__I_103300_i_F_103487" - mandatory - "N_102383__I_103300_i_F_103502" - alternative - N_102383__I_103300_i_F_103505 - N_102383__I_103300_i_F_103508 - "N_102383__I_103300_i_F_103511" - alternative - N_102383__I_103300_i_F_103514 - N_102383__I_103300_i_F_103517 - "N_102383__I_103300_i_F_103520" - alternative - N_102383__I_103300_i_F_103523 - N_102383__I_103300_i_F_103526 - - optional - "N_102383__I_103300_i_F_103490" - alternative - N_102383__I_103300_i_F_103493 - N_102383__I_103300_i_F_103496 - N_102383__I_103300_i_F_103499 - N_102383__I_103300_i_F_103529 - "N_102383__I_103300_i_F_103532" - optional - N_102383__I_103300_i_F_103535 - "N_102383__I_103300_i_F_103538" - optional - N_102383__I_103300_i_F_103541 - - optional - "N_102383__I_103300_i_F_103460" - alternative - N_102383__I_103300_i_F_103463 - N_102383__I_103300_i_F_103466 - N_102383__I_103300_i_F_103469 - - optional - "N_102383__I_103300_i_F_103301" - alternative - N_102383__I_103300_i_F_103304 - N_102383__I_103300_i_F_103307 - N_102383__I_103300_i_F_103310 - N_102383__I_103300_i_F_103313 - N_102383__I_103300_i_F_103316 - N_102383__I_103300_i_F_103319 - N_102383__I_103300_i_F_103322 - N_102383__I_103300_i_F_103325 - N_102383__I_103300_i_F_103328 - N_102383__I_103300_i_F_103331 - N_102383__I_103300_i_F_103334 - N_102383__I_103300_i_F_103337 - N_102383__I_103300_i_F_103340 - N_102383__I_103300_i_F_103343 - "N_102383__I_103546_i_F_103544" - mandatory - "N_102383__I_103546_i_F_103592" - mandatory - "N_102383__I_103546_i_F_103610" - alternative - N_102383__I_103546_i_F_103613 - N_102383__I_103546_i_F_103616 - N_102383__I_103546_i_F_103619 - N_102383__I_103546_i_F_103622 - N_102383__I_103546_i_F_103625 - N_102383__I_103546_i_F_103628 - "N_102383__I_103546_i_F_103631" - mandatory - "N_102383__I_103546_i_F_103646" - alternative - N_102383__I_103546_i_F_103649 - N_102383__I_103546_i_F_103652 - "N_102383__I_103546_i_F_103655" - alternative - N_102383__I_103546_i_F_103658 - N_102383__I_103546_i_F_103661 - "N_102383__I_103546_i_F_103664" - alternative - N_102383__I_103546_i_F_103667 - N_102383__I_103546_i_F_103670 - - optional - "N_102383__I_103546_i_F_103634" - alternative - N_102383__I_103546_i_F_103637 - N_102383__I_103546_i_F_103640 - N_102383__I_103546_i_F_103643 - N_102383__I_103546_i_F_103673 - "N_102383__I_103546_i_F_103676" - alternative - N_102383__I_103546_i_F_103679 - N_102383__I_103546_i_F_103682 - "N_102383__I_103546_i_F_103685" - alternative - N_102383__I_103546_i_F_103688 - N_102383__I_103546_i_F_103691 - - optional - "N_102383__I_103546_i_F_103595" - alternative - N_102383__I_103546_i_F_103598 - N_102383__I_103546_i_F_103601 - N_102383__I_103546_i_F_103604 - N_102383__I_103546_i_F_103607 - "N_102383__I_103546_i_F_103694" - alternative - N_102383__I_103546_i_F_103697 - N_102383__I_103546_i_F_103700 - "N_102383__I_103546_i_F_103703" - mandatory - "N_102383__I_103546_i_F_103718" - alternative - N_102383__I_103546_i_F_103721 - N_102383__I_103546_i_F_103724 - N_102383__I_103546_i_F_103727 - N_102383__I_103546_i_F_103730 - "N_102383__I_103546_i_F_103733" - mandatory - "N_102383__I_103546_i_F_103748" - alternative - N_102383__I_103546_i_F_103751 - N_102383__I_103546_i_F_103754 - "N_102383__I_103546_i_F_103757" - alternative - N_102383__I_103546_i_F_103760 - N_102383__I_103546_i_F_103763 - "N_102383__I_103546_i_F_103766" - alternative - N_102383__I_103546_i_F_103769 - N_102383__I_103546_i_F_103772 - - optional - "N_102383__I_103546_i_F_103736" - alternative - N_102383__I_103546_i_F_103739 - N_102383__I_103546_i_F_103742 - N_102383__I_103546_i_F_103745 - N_102383__I_103546_i_F_103775 - "N_102383__I_103546_i_F_103778" - optional - N_102383__I_103546_i_F_103781 - "N_102383__I_103546_i_F_103784" - optional - N_102383__I_103546_i_F_103787 - - optional - "N_102383__I_103546_i_F_103706" - alternative - N_102383__I_103546_i_F_103709 - N_102383__I_103546_i_F_103712 - N_102383__I_103546_i_F_103715 - - optional - "N_102383__I_103546_i_F_103547" - alternative - N_102383__I_103546_i_F_103550 - N_102383__I_103546_i_F_103553 - N_102383__I_103546_i_F_103556 - N_102383__I_103546_i_F_103559 - N_102383__I_103546_i_F_103562 - N_102383__I_103546_i_F_103565 - N_102383__I_103546_i_F_103568 - N_102383__I_103546_i_F_103571 - N_102383__I_103546_i_F_103574 - N_102383__I_103546_i_F_103577 - N_102383__I_103546_i_F_103580 - N_102383__I_103546_i_F_103583 - N_102383__I_103546_i_F_103586 - N_102383__I_103546_i_F_103589 - - optional - "N_102383__F_102789" - alternative - N_102383__F_102790 - N_102383__F_102791 - N_102383__F_102792 - N_102383__F_102793 - N_102383__F_102794 - N_102383__F_102795 - N_102383__F_102796 - N_102383__F_102797 - N_102383__F_102798 - N_102383__F_102799 - N_102383__F_102800 - N_102383__F_102801 - N_102383__F_102802 - N_102383__F_102803 - N_102383__F_102804 - N_102383__F_102805 - "N_102383__I_102808_i_F_102806" - mandatory - "N_102383__I_102808_i_F_102809" - mandatory - "N_102383__I_102808_i_F_102821" - mandatory - N_102383__I_102808_i_F_102824 - "N_102383__I_102808_i_F_102827" - alternative - N_102383__I_102808_i_F_102830 - N_102383__I_102808_i_F_102833 - "N_102383__I_102808_i_F_102836" - alternative - N_102383__I_102808_i_F_102839 - N_102383__I_102808_i_F_102842 - "N_102383__I_102808_i_F_102845" - mandatory - "N_102383__I_102808_i_F_102845_xor" {abstract} - optional - "N_102383__I_102808_i_F_102848" - alternative - N_102383__I_102808_i_F_102851 - N_102383__I_102808_i_F_102854 - N_102383__I_102808_i_F_102857 - "N_102383__I_102808_i_F_102860" - alternative - N_102383__I_102808_i_F_102863 - N_102383__I_102808_i_F_102866 - "N_102383__I_102808_i_F_102869" - alternative - N_102383__I_102808_i_F_102872 - N_102383__I_102808_i_F_102875 - "N_102383__I_102808_i_F_102878" - alternative - N_102383__I_102808_i_F_102881 - N_102383__I_102808_i_F_102884 - - optional - "N_102383__I_102808_i_F_102812" - alternative - N_102383__I_102808_i_F_102815 - N_102383__I_102808_i_F_102818 - N_102383__I_102808_i_F_102887 - N_102383__I_102808_i_F_102890 - "N_102383__I_102808_i_F_102893" - mandatory - "N_102383__I_102808_i_F_102908" - mandatory - N_102383__I_102808_i_F_102911 - "N_102383__I_102808_i_F_102914" - mandatory - "N_102383__I_102808_i_F_102917" - alternative - N_102383__I_102808_i_F_102920 - N_102383__I_102808_i_F_102923 - N_102383__I_102808_i_F_102926 - N_102383__I_102808_i_F_102929 - "N_102383__I_102808_i_F_102932" - alternative - N_102383__I_102808_i_F_102935 - N_102383__I_102808_i_F_102938 - N_102383__I_102808_i_F_102941 - N_102383__I_102808_i_F_102944 - "N_102383__I_102808_i_F_102947" - alternative - N_102383__I_102808_i_F_102950 - N_102383__I_102808_i_F_102953 - N_102383__I_102808_i_F_102956 - "N_102383__I_102808_i_F_102959" - alternative - N_102383__I_102808_i_F_102962 - N_102383__I_102808_i_F_102965 - N_102383__I_102808_i_F_102968 - N_102383__I_102808_i_F_102971 - "N_102383__I_102808_i_F_102974" - alternative - N_102383__I_102808_i_F_102977 - N_102383__I_102808_i_F_102980 - N_102383__I_102808_i_F_102983 - "N_102383__I_102808_i_F_102986" - alternative - N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_102992 - N_102383__I_102808_i_F_102995 - "N_102383__I_102808_i_F_102998" - alternative - N_102383__I_102808_i_F_103001 - N_102383__I_102808_i_F_103004 - - optional - "N_102383__I_102808_i_F_102896" - alternative - N_102383__I_102808_i_F_102899 - N_102383__I_102808_i_F_102902 - N_102383__I_102808_i_F_102905 - "N_102383__I_102808_i_F_102806_xor" {abstract} - optional - "N_102383__I_102808_i_F_103007" - alternative - N_102383__I_102808_i_F_103010 - N_102383__I_102808_i_F_103013 - N_102383__I_102808_i_F_103016 - N_102383__I_102808_i_F_103019 - N_102383__I_102808_i_F_103022 - N_102383__I_102808_i_F_103025 - N_102383__I_102808_i_F_103028 - N_102383__I_102808_i_F_103031 - N_102383__I_102808_i_F_103034 - N_102383__I_102808_i_F_103037 - N_102383__I_102808_i_F_103040 - N_102383__I_102808_i_F_103043 - N_102383__I_102808_i_F_103046 - N_102383__I_102808_i_F_103049 - "N_102383__I_103054_i_F_103052" - mandatory - "N_102383__I_103054_i_F_103055" - mandatory - "N_102383__I_103054_i_F_103067" - mandatory - N_102383__I_103054_i_F_103070 - "N_102383__I_103054_i_F_103073" - alternative - N_102383__I_103054_i_F_103076 - N_102383__I_103054_i_F_103079 - "N_102383__I_103054_i_F_103082" - alternative - N_102383__I_103054_i_F_103085 - N_102383__I_103054_i_F_103088 - "N_102383__I_103054_i_F_103091" - mandatory - "N_102383__I_103054_i_F_103091_xor" {abstract} - optional - "N_102383__I_103054_i_F_103094" - alternative - N_102383__I_103054_i_F_103097 - N_102383__I_103054_i_F_103100 - N_102383__I_103054_i_F_103103 - "N_102383__I_103054_i_F_103106" - alternative - N_102383__I_103054_i_F_103109 - N_102383__I_103054_i_F_103112 - "N_102383__I_103054_i_F_103115" - alternative - N_102383__I_103054_i_F_103118 - N_102383__I_103054_i_F_103121 - "N_102383__I_103054_i_F_103124" - alternative - N_102383__I_103054_i_F_103127 - N_102383__I_103054_i_F_103130 - - optional - "N_102383__I_103054_i_F_103058" - alternative - N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103064 - N_102383__I_103054_i_F_103133 - N_102383__I_103054_i_F_103136 - "N_102383__I_103054_i_F_103139" - mandatory - "N_102383__I_103054_i_F_103154" - mandatory - N_102383__I_103054_i_F_103157 - "N_102383__I_103054_i_F_103160" - mandatory - "N_102383__I_103054_i_F_103163" - alternative - N_102383__I_103054_i_F_103166 - N_102383__I_103054_i_F_103169 - N_102383__I_103054_i_F_103172 - N_102383__I_103054_i_F_103175 - "N_102383__I_103054_i_F_103178" - alternative - N_102383__I_103054_i_F_103181 - N_102383__I_103054_i_F_103184 - N_102383__I_103054_i_F_103187 - N_102383__I_103054_i_F_103190 - "N_102383__I_103054_i_F_103193" - alternative - N_102383__I_103054_i_F_103196 - N_102383__I_103054_i_F_103199 - N_102383__I_103054_i_F_103202 - "N_102383__I_103054_i_F_103205" - alternative - N_102383__I_103054_i_F_103208 - N_102383__I_103054_i_F_103211 - N_102383__I_103054_i_F_103214 - N_102383__I_103054_i_F_103217 - "N_102383__I_103054_i_F_103220" - alternative - N_102383__I_103054_i_F_103223 - N_102383__I_103054_i_F_103226 - N_102383__I_103054_i_F_103229 - "N_102383__I_103054_i_F_103232" - alternative - N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103238 - N_102383__I_103054_i_F_103241 - "N_102383__I_103054_i_F_103244" - alternative - N_102383__I_103054_i_F_103247 - N_102383__I_103054_i_F_103250 - - optional - "N_102383__I_103054_i_F_103142" - alternative - N_102383__I_103054_i_F_103145 - N_102383__I_103054_i_F_103148 - N_102383__I_103054_i_F_103151 - "N_102383__I_103054_i_F_103052_xor" {abstract} - optional - "N_102383__I_103054_i_F_103253" - alternative - N_102383__I_103054_i_F_103256 - N_102383__I_103054_i_F_103259 - N_102383__I_103054_i_F_103262 - N_102383__I_103054_i_F_103265 - N_102383__I_103054_i_F_103268 - N_102383__I_103054_i_F_103271 - N_102383__I_103054_i_F_103274 - N_102383__I_103054_i_F_103277 - N_102383__I_103054_i_F_103280 - N_102383__I_103054_i_F_103283 - N_102383__I_103054_i_F_103286 - N_102383__I_103054_i_F_103289 - N_102383__I_103054_i_F_103292 - N_102383__I_103054_i_F_103295 - "N_102383__I_103792_i_F_103790" - mandatory - "N_102383__I_103792_i_F_103838" - mandatory - "N_102383__I_103792_i_F_103856" - alternative - N_102383__I_103792_i_F_103859 - N_102383__I_103792_i_F_103862 - N_102383__I_103792_i_F_103865 - N_102383__I_103792_i_F_103868 - N_102383__I_103792_i_F_103871 - N_102383__I_103792_i_F_103874 - "N_102383__I_103792_i_F_103877" - mandatory - "N_102383__I_103792_i_F_103892" - alternative - N_102383__I_103792_i_F_103895 - N_102383__I_103792_i_F_103898 - "N_102383__I_103792_i_F_103901" - alternative - N_102383__I_103792_i_F_103904 - N_102383__I_103792_i_F_103907 - "N_102383__I_103792_i_F_103910" - alternative - N_102383__I_103792_i_F_103913 - N_102383__I_103792_i_F_103916 - - optional - "N_102383__I_103792_i_F_103880" - alternative - N_102383__I_103792_i_F_103883 - N_102383__I_103792_i_F_103886 - N_102383__I_103792_i_F_103889 - N_102383__I_103792_i_F_103919 - "N_102383__I_103792_i_F_103922" - alternative - N_102383__I_103792_i_F_103925 - N_102383__I_103792_i_F_103928 - "N_102383__I_103792_i_F_103931" - alternative - N_102383__I_103792_i_F_103934 - N_102383__I_103792_i_F_103937 - - optional - "N_102383__I_103792_i_F_103841" - alternative - N_102383__I_103792_i_F_103844 - N_102383__I_103792_i_F_103847 - N_102383__I_103792_i_F_103850 - N_102383__I_103792_i_F_103853 - "N_102383__I_103792_i_F_103940" - alternative - N_102383__I_103792_i_F_103943 - N_102383__I_103792_i_F_103946 - "N_102383__I_103792_i_F_103949" - mandatory - "N_102383__I_103792_i_F_103964" - alternative - N_102383__I_103792_i_F_103967 - N_102383__I_103792_i_F_103970 - N_102383__I_103792_i_F_103973 - N_102383__I_103792_i_F_103976 - "N_102383__I_103792_i_F_103979" - mandatory - "N_102383__I_103792_i_F_103994" - alternative - N_102383__I_103792_i_F_103997 - N_102383__I_103792_i_F_104000 - "N_102383__I_103792_i_F_104003" - alternative - N_102383__I_103792_i_F_104006 - N_102383__I_103792_i_F_104009 - "N_102383__I_103792_i_F_104012" - alternative - N_102383__I_103792_i_F_104015 - N_102383__I_103792_i_F_104018 - - optional - "N_102383__I_103792_i_F_103982" - alternative - N_102383__I_103792_i_F_103985 - N_102383__I_103792_i_F_103988 - N_102383__I_103792_i_F_103991 - N_102383__I_103792_i_F_104021 - "N_102383__I_103792_i_F_104024" - optional - N_102383__I_103792_i_F_104027 - "N_102383__I_103792_i_F_104030" - optional - N_102383__I_103792_i_F_104033 - - optional - "N_102383__I_103792_i_F_103952" - alternative - N_102383__I_103792_i_F_103955 - N_102383__I_103792_i_F_103958 - N_102383__I_103792_i_F_103961 - - optional - "N_102383__I_103792_i_F_103793" - alternative - N_102383__I_103792_i_F_103796 - N_102383__I_103792_i_F_103799 - N_102383__I_103792_i_F_103802 - N_102383__I_103792_i_F_103805 - N_102383__I_103792_i_F_103808 - N_102383__I_103792_i_F_103811 - N_102383__I_103792_i_F_103814 - N_102383__I_103792_i_F_103817 - N_102383__I_103792_i_F_103820 - N_102383__I_103792_i_F_103823 - N_102383__I_103792_i_F_103826 - N_102383__I_103792_i_F_103829 - N_102383__I_103792_i_F_103832 - N_102383__I_103792_i_F_103835 - "N_102383__I_104038_i_F_104036" - mandatory - "N_102383__I_104038_i_F_104084" - mandatory - "N_102383__I_104038_i_F_104102" - alternative - N_102383__I_104038_i_F_104105 - N_102383__I_104038_i_F_104108 - N_102383__I_104038_i_F_104111 - N_102383__I_104038_i_F_104114 - N_102383__I_104038_i_F_104117 - N_102383__I_104038_i_F_104120 - "N_102383__I_104038_i_F_104123" - mandatory - "N_102383__I_104038_i_F_104138" - alternative - N_102383__I_104038_i_F_104141 - N_102383__I_104038_i_F_104144 - "N_102383__I_104038_i_F_104147" - alternative - N_102383__I_104038_i_F_104150 - N_102383__I_104038_i_F_104153 - "N_102383__I_104038_i_F_104156" - alternative - N_102383__I_104038_i_F_104159 - N_102383__I_104038_i_F_104162 - - optional - "N_102383__I_104038_i_F_104126" - alternative - N_102383__I_104038_i_F_104129 - N_102383__I_104038_i_F_104132 - N_102383__I_104038_i_F_104135 - N_102383__I_104038_i_F_104165 - "N_102383__I_104038_i_F_104168" - alternative - N_102383__I_104038_i_F_104171 - N_102383__I_104038_i_F_104174 - "N_102383__I_104038_i_F_104177" - alternative - N_102383__I_104038_i_F_104180 - N_102383__I_104038_i_F_104183 - - optional - "N_102383__I_104038_i_F_104087" - alternative - N_102383__I_104038_i_F_104090 - N_102383__I_104038_i_F_104093 - N_102383__I_104038_i_F_104096 - N_102383__I_104038_i_F_104099 - "N_102383__I_104038_i_F_104186" - alternative - N_102383__I_104038_i_F_104189 - N_102383__I_104038_i_F_104192 - "N_102383__I_104038_i_F_104195" - mandatory - "N_102383__I_104038_i_F_104210" - alternative - N_102383__I_104038_i_F_104213 - N_102383__I_104038_i_F_104216 - N_102383__I_104038_i_F_104219 - N_102383__I_104038_i_F_104222 - "N_102383__I_104038_i_F_104225" - mandatory - "N_102383__I_104038_i_F_104240" - alternative - N_102383__I_104038_i_F_104243 - N_102383__I_104038_i_F_104246 - "N_102383__I_104038_i_F_104249" - alternative - N_102383__I_104038_i_F_104252 - N_102383__I_104038_i_F_104255 - "N_102383__I_104038_i_F_104258" - alternative - N_102383__I_104038_i_F_104261 - N_102383__I_104038_i_F_104264 - - optional - "N_102383__I_104038_i_F_104228" - alternative - N_102383__I_104038_i_F_104231 - N_102383__I_104038_i_F_104234 - N_102383__I_104038_i_F_104237 - N_102383__I_104038_i_F_104267 - "N_102383__I_104038_i_F_104270" - optional - N_102383__I_104038_i_F_104273 - "N_102383__I_104038_i_F_104276" - optional - N_102383__I_104038_i_F_104279 - - optional - "N_102383__I_104038_i_F_104198" - alternative - N_102383__I_104038_i_F_104201 - N_102383__I_104038_i_F_104204 - N_102383__I_104038_i_F_104207 - - optional - "N_102383__I_104038_i_F_104039" - alternative - N_102383__I_104038_i_F_104042 - N_102383__I_104038_i_F_104045 - N_102383__I_104038_i_F_104048 - N_102383__I_104038_i_F_104051 - N_102383__I_104038_i_F_104054 - N_102383__I_104038_i_F_104057 - N_102383__I_104038_i_F_104060 - N_102383__I_104038_i_F_104063 - N_102383__I_104038_i_F_104066 - N_102383__I_104038_i_F_104069 - N_102383__I_104038_i_F_104072 - N_102383__I_104038_i_F_104075 - N_102383__I_104038_i_F_104078 - N_102383__I_104038_i_F_104081 - N_104282__F_104283 - - optional - "N_104284__F_104285" - mandatory - "N_104284__F_104286" - alternative - N_104284__F_104287 - N_104284__F_104288 - "N_104284__F_104289" - mandatory - "N_104284__F_104290" - mandatory - "N_104284__F_104290_xor" {abstract} - alternative - "N_104284__F_104291" - optional - "N_104284__F_104292" - optional - N_104284__F_104293 - "N_104284__F_104294" - alternative - N_104284__F_104295 - N_104284__F_104296 - "N_104284__F_104308" - alternative - N_104284__F_104309 - N_104284__F_104310 - - optional - "N_104284__F_104297" - alternative - "N_104284__F_104298" - alternative - "N_104284__F_104299" - alternative - N_104284__F_104300 - N_104284__F_104301 - N_104284__F_104302 - "N_104284__F_104303" - alternative - "N_104284__F_104304" - alternative - N_104284__F_104305 - N_104284__F_104306 - N_104284__F_104307 - - optional - "N_104284__F_104311" - mandatory - "N_104284__F_104312" - alternative - N_104284__F_104313 - N_104284__F_104314 - "N_104284__F_104326" - alternative - N_104284__F_104327 - N_104284__F_104328 - - optional - "N_104284__F_104315" - alternative - "N_104284__F_104316" - alternative - "N_104284__F_104317" - alternative - N_104284__F_104318 - N_104284__F_104319 - N_104284__F_104320 - "N_104284__F_104321" - alternative - "N_104284__F_104322" - alternative - N_104284__F_104323 - N_104284__F_104324 - N_104284__F_104325 - N_104284__F_104329 - - optional - "N_104284__F_104330" - or - N_104284__F_104331 - N_104284__F_104332 - N_104284__F_104333 - "N_104334__F_104335" - mandatory - "N_104334__F_104336" - alternative - N_104334__F_104337 - N_104334__F_104338 - N_104334__F_104339 - N_104334__F_104340 - N_104334__F_104341 - "N_104334__F_104342" - mandatory - "N_104334__F_104343" - alternative - N_104334__F_104344 - N_104334__F_104345 - "N_104334__F_104346" - alternative - N_104334__F_104347 - N_104334__F_104348 - "N_104334__F_104349" - alternative - N_104334__F_104350 - N_104334__F_104351 - "N_104334__F_104352" - alternative - N_104334__F_104353 - N_104334__F_104354 - N_100000__F_104355 - "N_100000__F_104356" - mandatory - "N_104357__F_104358" - mandatory - "N_104357__F_104359" - alternative - N_104357__F_104360 - N_104357__F_104361 - N_104357__F_104362 - N_104357__F_104363 - N_104357__F_104364 - N_104357__F_104365 - N_104357__F_104366 - N_104357__F_104367 - N_104357__F_104368 - N_104357__F_104369 - N_104357__F_104370 - N_104357__F_104371 - N_104357__F_104372 - N_104357__F_104373 - N_104357__F_104374 - N_104357__F_104375 - N_104357__F_104376 - N_104357__F_104377 - N_104357__F_104378 - N_104357__F_104379 - N_104357__F_104380 - N_104357__F_104381 - N_104357__F_104382 - "N_104357__F_104408" - mandatory - "N_104357__F_104409" - mandatory - "N_104357__F_104410" - alternative - N_104357__F_104411 - N_104357__F_104412 - N_104357__F_104413 - N_104357__F_104414 - N_104357__F_104415 - N_104357__F_104416 - N_104357__F_104417 - N_104357__F_104418 - N_104357__F_104419 - N_104357__F_104420 - N_104357__F_104421 - N_104357__F_104422 - N_104357__F_104423 - N_104357__F_104424 - N_104357__F_104425 - N_104357__F_104426 - "N_104357__F_104427" - alternative - N_104357__F_104428 - N_104357__F_104429 - N_104357__F_104430 - N_104357__F_104431 - N_104357__F_104432 - "N_104357__F_104433" - alternative - N_104357__F_104434 - N_104357__F_104435 - N_104357__F_104436 - N_104357__F_104437 - N_104357__F_104438 - N_104357__F_104439 - N_104357__F_104440 - "N_104357__F_104441" - alternative - N_104357__F_104442 - N_104357__F_104443 - N_104357__F_104444 - N_104357__F_104445 - "N_104357__F_104446" - alternative - N_104357__F_104447 - N_104357__F_104448 - N_104357__F_104449 - "N_104357__F_104450" - alternative - N_104357__F_104451 - N_104357__F_104452 - N_104357__F_104453 - N_104357__F_104454 - "N_104357__F_104455" - mandatory - "N_104357__F_104456" - alternative - N_104357__F_104457 - N_104357__F_104458 - "N_104357__F_104459" - mandatory - "N_104357__F_104460" - alternative - N_104357__F_104461 - N_104357__F_104462 - "N_104357__F_104463" - mandatory - "N_104357__F_104463_xor" {abstract} - alternative - N_104357__F_104464 - N_104357__F_104465 - N_104357__F_104466 - - optional - "N_104357__F_104467" - alternative - N_104357__F_104468 - N_104357__F_104469 - "N_104357__F_104470" - mandatory - "N_104357__F_104471" - alternative - N_104357__F_104472 - N_104357__F_104473 - N_104357__F_104474 - N_104357__F_104475 - "N_104357__F_104476" - mandatory - "N_104357__F_104477" - alternative - N_104357__F_104478 - "N_104357__F_104479" - optional - N_104357__F_104480 - N_104357__F_104481 - "N_104357__F_104482" - mandatory - "N_104357__F_104483" - alternative - N_104357__F_104484 - N_104357__F_104485 - "N_104357__F_104486" - alternative - N_104357__F_104487 - N_104357__F_104488 - "N_104357__F_104489" - alternative - N_104357__F_104490 - N_104357__F_104491 - "N_104357__F_104492" - mandatory - "N_104357__F_104493" - alternative - N_104357__F_104494 - N_104357__F_104495 - "N_104357__F_104496" - mandatory - "N_104357__F_104496_xor" {abstract} - alternative - N_104357__F_104500 - "N_104357__F_104501" - optional - N_104357__F_104502 - N_104357__F_104503 - "N_104357__F_104510" - alternative - N_104357__F_104511 - N_104357__F_104512 - N_104357__F_104513 - - optional - "N_104357__F_104497" - alternative - N_104357__F_104498 - N_104357__F_104499 - "N_104357__F_104504" - optional - N_104357__F_104505 - "N_104357__F_104506" - alternative - N_104357__F_104507 - N_104357__F_104508 - N_104357__F_104509 - "N_104357__F_104514" - mandatory - "N_104357__F_104515" - alternative - N_104357__F_104516 - N_104357__F_104517 - "N_104357__F_104518" - alternative - N_104357__F_104519 - N_104357__F_104520 - - optional - "N_104357__F_104521" - optional - N_104357__F_104522 - N_104357__F_104523 - - optional - "N_104357__F_104383" - optional - "N_104357__F_104384" - optional - N_104357__F_104385 - "N_104357__F_104386" - alternative - N_104357__F_104387 - N_104357__F_104388 - "N_104357__F_104389" - alternative - N_104357__F_104390 - N_104357__F_104391 - "N_104357__F_104392" - alternative - N_104357__F_104393 - N_104357__F_104394 - N_104357__F_104395 - N_104357__F_104396 - "N_104357__F_104397" - mandatory - "N_104357__F_104398" - alternative - N_104357__F_104399 - N_104357__F_104400 - "N_104357__F_104401" - alternative - N_104357__F_104402 - N_104357__F_104403 - N_104357__F_104404 - N_104357__F_104405 - N_104357__F_104406 - N_104357__F_104407 - "N_104524__F_104525" - optional - N_104524__F_104526 - N_104524__F_104527 - N_104524__F_104528 - "N_104524__F_104529" - optional - N_104524__F_104530 - N_104524__F_104531 - N_104524__F_104532 - "N_104524__F_104533" - alternative - N_104524__F_104534 - N_104524__F_104535 - "N_104536__F_104537" - mandatory - "N_104536__F_104537_or" {abstract} - or - "N_104536__I_104551_i_F_104549" - mandatory - "N_104536__I_104551_i_F_104552" - alternative - N_104536__I_104551_i_F_104555 - N_104536__I_104551_i_F_104558 - - optional - N_104536__I_104551_i_F_104561 - "N_104536__I_104566_i_F_104564" - mandatory - "N_104536__I_104566_i_F_104567" - alternative - N_104536__I_104566_i_F_104570 - N_104536__I_104566_i_F_104573 - - optional - N_104536__I_104566_i_F_104576 - "N_104536__I_104581_i_F_104579" - mandatory - "N_104536__I_104581_i_F_104582" - alternative - N_104536__I_104581_i_F_104585 - N_104536__I_104581_i_F_104588 - - optional - N_104536__I_104581_i_F_104591 - "N_104536__I_104596_i_F_104594" - mandatory - "N_104536__I_104596_i_F_104597" - alternative - N_104536__I_104596_i_F_104600 - N_104536__I_104596_i_F_104603 - - optional - N_104536__I_104596_i_F_104606 - "N_104536__I_104611_i_F_104609" - mandatory - "N_104536__I_104611_i_F_104612" - alternative - N_104536__I_104611_i_F_104615 - N_104536__I_104611_i_F_104618 - - optional - N_104536__I_104611_i_F_104621 - "N_104536__I_104626_i_F_104624" - mandatory - "N_104536__I_104626_i_F_104627" - alternative - N_104536__I_104626_i_F_104630 - N_104536__I_104626_i_F_104633 - - optional - N_104536__I_104626_i_F_104636 - - optional - "N_104536__F_104538" - alternative - N_104536__F_104539 - N_104536__F_104540 - N_104536__F_104541 - N_104536__F_104542 - N_104536__F_104543 - N_104536__F_104544 - N_104536__F_104545 - "N_104536__F_104546" - alternative - N_104536__F_104547 - N_104536__F_104548 - "N_104536__F_104639" - alternative - N_104536__F_104640 - N_104536__F_104641 - "N_104642__F_104643" - mandatory - "N_104642__F_104644" - alternative - N_104642__F_104645 - N_104642__F_104646 - - optional - N_104642__F_104647 - "N_100000__F_104648" - mandatory - "N_104649__F_104650" - mandatory - "N_104649__F_104656" - mandatory - "N_104649__F_104657" - alternative - N_104649__F_104658 - N_104649__F_104659 - "N_104649__F_104660" - alternative - N_104649__F_104661 - N_104649__F_104662 - N_104649__F_104663 - N_104649__F_104664 - "N_104649__F_104665" - alternative - N_104649__F_104666 - N_104649__F_104667 - "N_104649__F_104668" - alternative - N_104649__F_104669 - N_104649__F_104670 - N_104649__F_104671 - N_104649__F_104672 - "N_104649__F_104673" - alternative - N_104649__F_104674 - N_104649__F_104675 - N_104649__F_104676 - N_104649__F_104677 - N_104649__F_104678 - N_104649__F_104679 - "N_104649__F_104680" - alternative - N_104649__F_104681 - N_104649__F_104682 - N_104649__F_104683 - N_104649__F_104684 - N_104649__F_104685 - N_104649__F_104686 - "N_104687__F_104688" - alternative - N_104687__F_104689 - N_104687__F_104690 - "N_104687__F_104691" - alternative - N_104687__F_104692 - N_104687__F_104693 - "N_104687__F_104694" - alternative - N_104687__F_104695 - N_104687__F_104696 - N_104687__F_104697 - N_104687__F_104698 - N_104687__F_104699 - "N_104700__F_104701" - alternative - "N_104700__F_104702" - alternative - N_104700__F_104703 - N_104700__F_104704 - N_104700__F_104705 - N_104700__F_104706 - N_104700__F_104707 - N_104700__F_104708 - N_104700__F_104709 - N_104700__F_104710 - N_104700__F_104711 - N_104700__F_104712 - N_104700__F_104713 - N_104700__F_104714 - N_104700__F_104715 - N_104700__F_104716 - N_104700__F_104717 - N_104700__F_104718 - N_104700__F_104719 - N_104700__F_104720 - N_104700__F_104721 - N_104700__F_104722 - N_104700__F_104723 - N_104700__F_104724 - "N_104700__F_104725" - optional - N_104700__F_104726 - "N_104649__F_104839" - alternative - N_104649__F_104840 - N_104649__F_104841 - N_104649__F_104842 - - optional - "N_104649__F_104651" - alternative - N_104649__F_104652 - N_104649__F_104653 - N_104649__F_104654 - N_104649__F_104655 - "N_104649__F_104727" - optional - "N_104649__F_104728" - alternative - N_104649__F_104729 - N_104649__F_104730 - "N_104649__F_104731" - optional - "N_104649__F_104732" - alternative - N_104649__F_104733 - N_104649__F_104734 - "N_104649__F_104735" - optional - "N_104649__F_104736" - alternative - N_104649__F_104737 - N_104649__F_104738 - N_104649__F_104739 - "N_104649__F_104740" - alternative - N_104649__F_104741 - N_104649__F_104742 - "N_104649__F_104743" - alternative - N_104649__F_104744 - N_104649__F_104745 - "N_104649__F_104746" - alternative - N_104649__F_104747 - N_104649__F_104748 - N_104649__F_104749 - "N_104649__F_104750" - optional - N_104649__F_104751 - N_104649__F_104752 - N_104649__F_104753 - N_104649__F_104754 - N_104649__F_104755 - N_104649__F_104756 - "N_104649__F_104757" - alternative - N_104649__F_104758 - N_104649__F_104759 - "N_104649__F_104760" - or - "N_104649__F_104761" - mandatory - "N_104649__F_104762" - mandatory - "N_104649__F_104763" - alternative - N_104649__F_104764 - N_104649__F_104765 - "N_104649__F_104766" - alternative - N_104649__F_104767 - N_104649__F_104768 - "N_104649__F_104769" - alternative - N_104649__F_104770 - N_104649__F_104771 - "N_104649__F_104772" - mandatory - N_104649__F_104773 - - optional - N_104649__F_104774 - "N_104649__F_104775" - mandatory - "N_104649__F_104776" - mandatory - "N_104649__F_104777" - alternative - N_104649__F_104778 - N_104649__F_104779 - "N_104649__F_104780" - alternative - N_104649__F_104781 - N_104649__F_104782 - "N_104649__F_104783" - alternative - N_104649__F_104784 - N_104649__F_104785 - "N_104649__F_104786" - mandatory - N_104649__F_104787 - - optional - N_104649__F_104788 - "N_104649__F_104789" - mandatory - "N_104649__F_104790" - mandatory - "N_104649__F_104791" - alternative - N_104649__F_104792 - N_104649__F_104793 - "N_104649__F_104794" - alternative - N_104649__F_104795 - N_104649__F_104796 - "N_104649__F_104797" - alternative - N_104649__F_104798 - N_104649__F_104799 - "N_104649__F_104800" - mandatory - N_104649__F_104801 - "N_104649__F_104802" - mandatory - "N_104649__F_104803" - mandatory - "N_104649__F_104804" - alternative - N_104649__F_104805 - N_104649__F_104806 - "N_104649__F_104807" - alternative - N_104649__F_104808 - N_104649__F_104809 - "N_104649__F_104810" - mandatory - N_104649__F_104811 - "N_104649__F_104812" - mandatory - N_104649__F_104813 - "N_104649__F_104814" - optional - "N_104649__I_104817_i_F_104815" - mandatory - "N_104649__I_104817_i_F_104818" - alternative - N_104649__I_104817_i_F_104821 - N_104649__I_104817_i_F_104824 - "N_104649__I_104817_i_F_104827" - mandatory - "N_104649__I_104817_i_F_104830" - alternative - N_104649__I_104817_i_F_104833 - N_104649__I_104817_i_F_104836 - "N_104843__F_104844" - optional - "N_104843__F_104845" - alternative - N_104843__F_104846 - N_104843__F_104847 - N_104843__F_104848 - "N_104849__F_104850" - alternative - N_104849__F_104851 - N_104849__F_104852 - N_104849__F_104853 - - optional - "N_100000__F_104854" - optional - "N_100000__F_104855" - optional - N_100000__F_104856 - N_100000__F_104857 - N_100000__F_104858 - -constraints - "N_100002__F_100005" => N_100002__F_100015 - "N_100002__F_100005" => N_100002__F_100107 - "N_100002__F_100005" => "N_100002__F_100013" - N_100002__F_100007 => N_100002__F_100015 - N_100002__F_100007 => N_100002__F_100108 - N_100002__F_100007 => "N_100002__F_100013" - N_100002__F_100008 => N_100002__F_100016 - N_100002__F_100008 => N_100002__F_100107 - N_100002__F_100008 => "N_100002__F_100013" - N_100002__F_100009 => N_100002__F_100016 - N_100002__F_100009 => N_100002__F_100108 - N_100002__F_100009 => "N_100002__F_100013" - N_100002__F_100010 => N_100002__F_100109 - N_100002__F_100011 => "N_100002__F_100017" - !("N_100002__F_100013" & "N_100300__F_100332") - !("N_100002__F_100013" & "N_100130__F_100297") - N_100002__F_100105 => "N_100300__F_100332" - !(N_100002__F_100105 & "N_100130__F_100132") - N_100002__F_100111 => "N_104536__F_104538" - N_100002__F_100112 => "N_104536__F_104546" - "N_100300__F_100303" => N_100300__F_100341 - N_100300__F_100321 => N_100000__F_101763 - N_100300__F_100321 => N_100300__F_100342 - N_100300__F_100321 => N_104282__F_104283 - !(N_100300__F_100321 & "N_102383__F_102384") - N_100300__F_100321 => N_100000__F_101282 - !(N_100300__F_100321 & N_100000__F_101275) - !(N_100300__F_100321 & N_100000__F_101276) - !(N_100300__F_100321 & N_100000__F_101277) - !(N_100300__F_100321 & N_100000__F_101278) - !(N_100300__F_100321 & N_100000__F_101279) - !(N_100300__F_100321 & N_100000__F_101280) - !(N_100300__F_100321 & N_100000__F_101281) - N_100300__F_100321 => N_100300__F_100339 - N_100300__F_100341 => "N_102383__F_102384" - N_100300__F_100342 => N_104282__F_104283 - N_100353__F_100357 => N_100353__F_100359 - N_100353__F_100357 => N_100353__F_100360 - N_100353__F_100357 => N_100353__F_100361 - N_100353__F_100357 => N_100353__F_100368 - N_100353__F_100357 => N_100353__F_100363 - N_100353__F_100357 => N_100353__F_100364 - N_100353__F_100357 => "N_100353__F_100370" - N_100353__F_100357 => "N_100353__F_100380" - N_100353__F_100357 => "N_100353__F_100390" - N_100353__F_100357 => "N_100353__F_100447" - N_100353__F_100357 => "N_100353__F_100454" - N_100353__F_100357 => "N_100353__F_100456" - N_100353__F_100359 => "N_101764__F_101765" - N_100353__F_100360 => "N_101764__F_101765" - N_100353__F_100361 => "N_101764__F_101765" - "N_100353__F_100370" => "N_100618__F_100674" - "N_100353__F_100380" => "N_100618__F_100732" - "N_100353__F_100386" => "N_100618__F_100648" - "N_100353__F_100390" => "N_100618__F_100759" - "N_100353__F_100405" => "N_101906__F_101907" - "N_100353__F_100421" => "N_100618__F_100790" - N_100353__F_100433 => "N_100469__I_100554_i_F_100552" - N_100353__F_100434 => "N_100469__I_100542_i_F_100540" - "N_100353__F_100447" => "N_102043__F_102283" - "N_100353__F_100454" => "N_102043__F_102333" - "N_100353__F_100456" => "N_102043__F_102356" - N_100353__F_100461 => "N_102043__F_102194" - N_102026__F_102028 => N_102026__F_102031 - N_100002__F_100006 => N_100002__F_100111 - "N_100130__F_100138" => "N_100000__I_100976_i_F_100974" - "N_100130__F_100138" => "N_100000__I_101174_i_F_101172" - "N_100130__F_100153" => N_100353__F_100361 - N_100130__F_100169 => N_100353__F_100429 - N_100130__F_100169 => N_100353__F_100432 - N_100130__F_100169 => N_100353__F_100414 - N_100130__F_100169 => N_100353__F_100431 - N_100130__F_100169 => N_100353__F_100409 - "N_100130__F_100225" => N_100353__F_100431 - "N_100130__F_100225" => N_100353__F_100414 - "N_100130__F_100225" => "N_100130__F_100218" - N_100130__F_100266 => N_100353__F_100430 - "N_100130__F_100283" => N_100353__F_100360 - N_100130__F_100290 => N_100353__F_100461 - N_100353__F_100367 => "N_101932__F_101933" - N_100353__F_100368 => "N_101932__F_101933" - N_100353__F_100369 => "N_101932__F_101933" - N_100353__F_100371 => N_100618__F_100702 - N_100353__F_100372 => N_100618__F_100697 - N_100353__F_100373 => N_100618__F_100696 - N_100353__F_100374 => N_100618__F_100699 - N_100353__F_100375 => N_100618__F_100700 - N_100353__F_100376 => N_100618__F_100701 - N_100353__F_100377 => N_100618__F_100704 - N_100353__F_100378 => N_100618__F_100703 - N_100353__F_100379 => N_100618__F_100698 - N_100353__F_100381 => N_100618__F_100757 - N_100353__F_100382 => N_100618__F_100755 - N_100353__F_100383 => N_100618__F_100758 - N_100353__F_100384 => N_100618__F_100756 - N_100353__F_100385 => N_100618__F_100754 - N_100353__F_100422 => N_100618__F_100812 - N_100353__F_100423 => N_100618__F_100813 - N_100353__F_100424 => N_100618__F_100814 - N_100353__F_100425 => N_100618__F_100815 - N_100353__F_100426 => N_100618__F_100816 - N_100353__F_100427 => N_100618__F_100817 - N_100353__F_100429 => N_100618__F_100818 - N_100353__F_100430 => N_100618__F_100819 - N_100353__F_100448 => N_102043__F_102305 - N_100353__F_100449 => N_102043__F_102307 - N_100353__F_100450 => N_102043__F_102306 - N_100353__F_100451 => N_102043__F_102309 - N_100353__F_100452 => N_102043__F_102310 - N_100353__F_100453 => N_102043__F_102308 - N_100353__F_100457 => N_102043__F_102379 - N_100353__F_100458 => N_102043__F_102380 - N_100353__F_100459 => N_102043__F_102381 - N_100353__F_100460 => N_102043__F_102378 - !("N_101906__F_101907" & N_104687__F_104698) - !(N_102026__F_102031 & N_102026__F_102030) - "N_100002__F_100020" => "N_100002__F_100034" - "N_100002__F_100020" => "N_100002__F_100036" - N_100130__F_100147 => N_102026__F_102028 - N_100130__F_100284 => "N_100130__F_100225" - N_100300__F_100312 => "N_100300__F_100330" - N_100300__F_100313 => N_100300__F_100324 - N_100300__F_100313 => "N_100300__F_100325" - "N_100300__F_100314" => N_100300__F_100324 - N_100300__F_100318 => N_100300__F_100324 - N_100300__F_100319 => N_100300__F_100324 - N_100300__F_100319 => "N_100300__F_100325" - N_100300__F_100326 => N_100300__F_100341 - N_100300__F_100326 => N_100000__F_104355 - N_100300__F_100326 => N_100000__F_102003 - N_100000__F_101275 => N_100000__I_101285_i_F_101337 - !(N_100000__F_101275 & "N_100000__I_101405_i_F_101403") - !(N_100000__F_101275 & "N_100000__I_101525_i_F_101523") - !(N_100000__F_101275 & "N_100000__I_101645_i_F_101643") - N_100000__F_101275 => N_100000__I_101285_i_F_101394 - N_100000__F_101276 => N_100000__I_101285_i_F_101340 - !(N_100000__F_101276 & "N_100000__I_101405_i_F_101403") - !(N_100000__F_101276 & "N_100000__I_101525_i_F_101523") - !(N_100000__F_101276 & "N_100000__I_101645_i_F_101643") - N_100000__F_101276 => N_100000__I_101285_i_F_101394 - N_100000__F_101277 => N_100000__I_101285_i_F_101337 - N_100000__F_101277 => N_100000__I_101405_i_F_101469 - !(N_100000__F_101277 & "N_100000__I_101525_i_F_101523") - !(N_100000__F_101277 & "N_100000__I_101645_i_F_101643") - N_100000__F_101277 => N_100000__I_101285_i_F_101394 - N_100000__F_101277 => N_100000__I_101405_i_F_101514 - N_100000__F_101278 => N_100000__I_101285_i_F_101337 - N_100000__F_101278 => N_100000__I_101405_i_F_101469 - N_100000__F_101278 => N_100000__I_101525_i_F_101586 - !(N_100000__F_101278 & "N_100000__I_101645_i_F_101643") - N_100000__F_101278 => N_100000__I_101285_i_F_101394 - N_100000__F_101278 => N_100000__I_101405_i_F_101517 - N_100000__F_101278 => N_100000__I_101525_i_F_101637 - N_100000__F_101279 => N_100000__I_101285_i_F_101340 - N_100000__F_101279 => N_100000__I_101405_i_F_101469 - N_100000__F_101279 => N_100000__I_101525_i_F_101586 - !(N_100000__F_101279 & "N_100000__I_101645_i_F_101643") - N_100000__F_101279 => N_100000__I_101285_i_F_101394 - N_100000__F_101279 => N_100000__I_101405_i_F_101517 - N_100000__F_101279 => N_100000__I_101525_i_F_101637 - N_100000__F_101280 => N_100000__I_101285_i_F_101337 - N_100000__F_101280 => N_100000__I_101405_i_F_101469 - N_100000__F_101280 => N_100000__I_101525_i_F_101592 - !(N_100000__F_101280 & "N_100000__I_101645_i_F_101643") - N_100000__F_101280 => N_100000__I_101285_i_F_101394 - N_100000__F_101280 => N_100000__I_101405_i_F_101517 - N_100000__F_101280 => N_100000__I_101525_i_F_101637 - N_100000__F_101281 => N_100000__I_101285_i_F_101340 - N_100000__F_101281 => N_100000__I_101405_i_F_101469 - N_100000__F_101281 => N_100000__I_101525_i_F_101592 - !(N_100000__F_101281 & "N_100000__I_101645_i_F_101643") - N_100000__F_101281 => N_100000__I_101285_i_F_101394 - N_100000__F_101281 => N_100000__I_101405_i_F_101517 - N_100000__F_101281 => N_100000__I_101525_i_F_101637 - N_100000__F_101282 => N_100000__I_101285_i_F_101340 - N_100000__F_101282 => N_100000__I_101645_i_F_101718 - !(N_100000__F_101282 & "N_100000__I_101405_i_F_101403") - !(N_100000__F_101282 & "N_100000__I_101525_i_F_101523") - N_100000__F_101282 => N_100000__I_101645_i_F_101751 - N_100000__F_101282 => N_100000__I_101285_i_F_101400 - "N_100000__I_101285_i_F_101283" => "N_100000__I_101285_i_F_101334" - "N_100000__I_101405_i_F_101403" => N_100000__I_101405_i_F_101469 - !("N_100000__I_101525_i_F_101523" & "N_100000__I_101525_i_F_101574") - !("N_100000__I_101525_i_F_101523" & N_100000__I_101525_i_F_101589) - N_104357__F_104360 => N_104357__F_104411 - N_104357__F_104360 => N_104357__F_104428 - N_104357__F_104360 => N_104357__F_104435 - N_104357__F_104360 => N_104357__F_104442 - N_104357__F_104360 => N_104357__F_104447 - N_104357__F_104360 => N_104357__F_104451 - !(N_104357__F_104360 & N_104357__F_104406) - N_104357__F_104361 => N_104357__F_104411 - N_104357__F_104361 => N_104357__F_104428 - N_104357__F_104361 => N_104357__F_104435 - N_104357__F_104361 => N_104357__F_104442 - N_104357__F_104361 => N_104357__F_104447 - N_104357__F_104361 => N_104357__F_104452 - !(N_104357__F_104361 & N_104357__F_104406) - N_104357__F_104362 => N_104357__F_104411 - N_104357__F_104362 => N_104357__F_104429 - N_104357__F_104362 => N_104357__F_104435 - N_104357__F_104362 => N_104357__F_104442 - N_104357__F_104362 => N_104357__F_104447 - N_104357__F_104362 => N_104357__F_104451 - !(N_104357__F_104362 & N_104357__F_104406) - N_104357__F_104363 => N_104357__F_104414 - N_104357__F_104363 => N_104357__F_104428 - N_104357__F_104363 => N_104357__F_104435 - N_104357__F_104363 => N_104357__F_104442 - N_104357__F_104363 => N_104357__F_104447 - N_104357__F_104363 => N_104357__F_104452 - !(N_104357__F_104363 & N_104357__F_104406) - N_104357__F_104364 => N_104357__F_104414 - N_104357__F_104364 => N_104357__F_104429 - N_104357__F_104364 => N_104357__F_104435 - N_104357__F_104364 => N_104357__F_104442 - N_104357__F_104364 => N_104357__F_104447 - N_104357__F_104364 => N_104357__F_104452 - !(N_104357__F_104364 & N_104357__F_104406) - N_104357__F_104365 => N_104357__F_104414 - N_104357__F_104365 => N_104357__F_104429 - N_104357__F_104365 => N_104357__F_104435 - N_104357__F_104365 => N_104357__F_104442 - N_104357__F_104365 => N_104357__F_104447 - N_104357__F_104365 => N_104357__F_104451 - !(N_104357__F_104365 & N_104357__F_104406) - N_104357__F_104366 => N_104357__F_104415 - N_104357__F_104366 => N_104357__F_104428 - N_104357__F_104366 => N_104357__F_104438 - N_104357__F_104366 => N_104357__F_104442 - N_104357__F_104366 => N_104357__F_104447 - N_104357__F_104366 => N_104357__F_104452 - N_104357__F_104367 => N_104357__F_104415 - N_104357__F_104367 => N_104357__F_104429 - N_104357__F_104367 => N_104357__F_104435 - N_104357__F_104367 => N_104357__F_104442 - N_104357__F_104367 => N_104357__F_104447 - N_104357__F_104367 => N_104357__F_104452 - !(N_104357__F_104367 & N_104357__F_104406) - N_104357__F_104368 => N_104357__F_104415 - N_104357__F_104368 => N_104357__F_104430 - N_104357__F_104368 => N_104357__F_104438 - N_104357__F_104368 => N_104357__F_104442 - N_104357__F_104368 => N_104357__F_104447 - N_104357__F_104368 => N_104357__F_104451 - N_104357__F_104369 => N_104357__F_104415 - N_104357__F_104369 => N_104357__F_104430 - N_104357__F_104369 => N_104357__F_104438 - N_104357__F_104369 => N_104357__F_104442 - N_104357__F_104369 => N_104357__F_104447 - N_104357__F_104369 => N_104357__F_104452 - N_104357__F_104370 => N_104357__F_104415 - N_104357__F_104370 => N_104357__F_104430 - N_104357__F_104370 => N_104357__F_104435 - N_104357__F_104370 => N_104357__F_104442 - N_104357__F_104370 => N_104357__F_104447 - N_104357__F_104370 => N_104357__F_104453 - N_104357__F_104371 => N_104357__F_104415 - N_104357__F_104371 => N_104357__F_104431 - N_104357__F_104371 => N_104357__F_104438 - N_104357__F_104371 => N_104357__F_104442 - N_104357__F_104371 => N_104357__F_104447 - N_104357__F_104371 => N_104357__F_104451 - N_104357__F_104372 => N_104357__F_104415 - N_104357__F_104372 => N_104357__F_104431 - N_104357__F_104372 => N_104357__F_104435 - N_104357__F_104372 => N_104357__F_104442 - N_104357__F_104372 => N_104357__F_104447 - N_104357__F_104372 => N_104357__F_104451 - !(N_104357__F_104372 & N_104357__F_104406) - N_104357__F_104373 => N_104357__F_104416 - N_104357__F_104373 => N_104357__F_104428 - N_104357__F_104373 => N_104357__F_104435 - N_104357__F_104373 => N_104357__F_104442 - N_104357__F_104373 => N_104357__F_104449 - N_104357__F_104373 => N_104357__F_104452 - !(N_104357__F_104373 & N_104357__F_104406) - N_104357__F_104374 => N_104357__F_104419 - N_104357__F_104374 => N_104357__F_104435 - N_104357__F_104374 => N_104357__F_104442 - N_104357__F_104374 => N_104357__F_104429 - N_104357__F_104374 => N_104357__F_104447 - N_104357__F_104374 => N_104357__F_104453 - !(N_104357__F_104374 & N_104357__F_104406) - N_104357__F_104375 => N_104357__F_104419 - N_104357__F_104375 => N_104357__F_104429 - N_104357__F_104375 => N_104357__F_104435 - N_104357__F_104375 => N_104357__F_104443 - N_104357__F_104375 => N_104357__F_104447 - N_104357__F_104375 => N_104357__F_104453 - N_104357__F_104376 => N_104357__F_104419 - N_104357__F_104376 => N_104357__F_104431 - N_104357__F_104376 => N_104357__F_104435 - N_104357__F_104376 => N_104357__F_104442 - N_104357__F_104376 => N_104357__F_104447 - N_104357__F_104376 => N_104357__F_104453 - N_104357__F_104377 => N_104357__F_104422 - N_104357__F_104377 => N_104357__F_104430 - N_104357__F_104377 => N_104357__F_104440 - N_104357__F_104377 => N_104357__F_104444 - N_104357__F_104377 => N_104357__F_104449 - N_104357__F_104377 => N_104357__F_104451 - N_104357__F_104378 => N_104357__F_104422 - N_104357__F_104378 => N_104357__F_104430 - N_104357__F_104378 => N_104357__F_104440 - N_104357__F_104378 => N_104357__F_104444 - N_104357__F_104378 => N_104357__F_104449 - N_104357__F_104378 => N_104357__F_104452 - N_104357__F_104379 => N_104357__F_104422 - N_104357__F_104379 => N_104357__F_104431 - N_104357__F_104379 => N_104357__F_104440 - N_104357__F_104379 => N_104357__F_104444 - N_104357__F_104379 => N_104357__F_104449 - N_104357__F_104379 => N_104357__F_104451 - N_104357__F_104380 => N_104357__F_104423 - N_104357__F_104380 => N_104357__F_104431 - N_104357__F_104380 => N_104357__F_104439 - N_104357__F_104380 => N_104357__F_104442 - N_104357__F_104380 => N_104357__F_104447 - N_104357__F_104380 => N_104357__F_104453 - N_104357__F_104381 => N_104357__F_104425 - N_104357__F_104381 => N_104357__F_104431 - N_104357__F_104381 => N_104357__F_104439 - N_104357__F_104381 => N_104357__F_104443 - N_104357__F_104381 => N_104357__F_104447 - N_104357__F_104381 => N_104357__F_104451 - N_104357__F_104382 => N_104357__F_104426 - N_104357__F_104382 => N_104357__F_104429 - N_104357__F_104382 => N_104357__F_104436 - N_104357__F_104382 => N_104357__F_104442 - N_104357__F_104382 => N_104357__F_104447 - N_104357__F_104382 => N_104357__F_104452 - !(N_104357__F_104382 & N_104357__F_104406) - !(N_104536__F_104539 & N_104536__F_104547) - !(N_104536__F_104539 & N_104536__F_104548) - N_104536__F_104539 => N_104700__F_104709 - N_104536__F_104539 => "N_104687__F_104691" - N_104536__F_104539 => "N_104687__F_104694" - !(N_104536__F_104540 & N_104536__F_104547) - !(N_104536__F_104540 & N_104536__F_104548) - N_104536__F_104540 => N_104700__F_104711 - N_104536__F_104540 => N_104700__F_104712 - N_104536__F_104540 => N_104700__F_104713 - N_104536__F_104540 => N_104700__F_104714 - N_104536__F_104540 => N_104700__F_104715 - N_104536__F_104540 => N_104700__F_104716 - N_104536__F_104540 => N_104700__F_104717 - N_104536__F_104540 => N_104700__F_104710 - N_104536__F_104540 => "N_104687__F_104691" - N_104536__F_104540 => "N_104687__F_104694" - !(N_104536__F_104541 & N_104536__F_104547) - !(N_104536__F_104541 & N_104536__F_104548) - N_104536__F_104541 => N_104700__F_104710 - N_104536__F_104541 => N_104700__F_104711 - N_104536__F_104541 => N_104700__F_104712 - N_104536__F_104541 => N_104700__F_104713 - N_104536__F_104541 => N_104700__F_104714 - N_104536__F_104541 => N_104700__F_104715 - N_104536__F_104541 => N_104700__F_104716 - N_104536__F_104541 => N_104700__F_104717 - N_104536__F_104541 => N_104687__F_104697 - N_104536__F_104541 => N_104687__F_104698 - !(N_104536__F_104542 & N_104536__F_104548) - N_104536__F_104542 => N_104700__F_104703 - N_104536__F_104542 => N_104700__F_104704 - N_104536__F_104542 => N_104700__F_104705 - N_104536__F_104542 => "N_104687__F_104691" - N_104536__F_104542 => "N_104687__F_104694" - !(N_104536__F_104543 & N_104536__F_104547) - N_104536__F_104543 => N_104700__F_104723 - N_104536__F_104543 => "N_104687__F_104691" - N_104536__F_104543 => "N_104687__F_104694" - !(N_104536__F_104544 & N_104536__F_104547) - !(N_104536__F_104544 & N_104536__F_104548) - N_104536__F_104544 => N_104700__F_104721 - !(N_104536__F_104545 & N_104536__F_104547) - !(N_104536__F_104545 & N_104536__F_104548) - N_104536__F_104545 => N_104700__F_104719 - N_104536__F_104547 => N_104700__F_104703 - N_104536__F_104547 => N_104700__F_104704 - N_104536__F_104547 => N_104700__F_104705 - N_104536__F_104547 => "N_104687__F_104691" - N_104536__F_104547 => "N_104687__F_104694" - N_104536__F_104548 => N_104700__F_104723 - N_104536__F_104548 => "N_104687__F_104691" - N_104536__F_104548 => "N_104687__F_104694" - !(N_104642__F_104645 & N_104642__F_104647) - N_104642__F_104646 => N_104642__F_104647 - N_104649__F_104652 => N_104649__F_104666 - N_104649__F_104652 => N_104649__F_104759 - N_104649__F_104652 => N_104649__F_104675 - N_104649__F_104652 => N_104649__F_104681 - N_104649__F_104653 => N_104649__F_104666 - "N_104649__F_104728" => N_100130__F_100280 - N_100300__F_100306 => N_100300__F_100324 - N_100300__F_100307 => N_100300__F_100324 - N_100300__F_100309 => N_100300__F_100324 - N_100300__F_100310 => N_100300__F_100324 - N_100469__I_100473_i_F_100474 => "N_104536__I_104551_i_F_104549" - N_100469__I_100473_i_F_100477 => "N_104536__I_104566_i_F_104564" - N_100469__I_100473_i_F_100480 => "N_104536__I_104581_i_F_104579" - N_100469__I_100473_i_F_100483 => "N_104536__I_104596_i_F_104594" - N_100469__I_100473_i_F_100486 => "N_104536__I_104611_i_F_104609" - N_100469__I_100473_i_F_100489 => "N_104536__I_104626_i_F_104624" - !(N_100000__I_100877_i_F_100959 & N_104687__F_104698) - !(N_100000__I_100976_i_F_101058 & N_104687__F_104698) - !(N_100000__I_101075_i_F_101157 & N_104687__F_104698) - !(N_100000__I_101174_i_F_101256 & N_104687__F_104698) - N_101764__F_101767 => "N_101764__F_101798" - N_101764__F_101767 => "N_101764__F_101783" - N_101764__F_101767 => "N_101764__F_101810" - N_101764__F_101767 => "N_101764__F_101835" - N_101764__F_101767 => "N_101764__F_101793" - N_101764__F_101767 => "N_101764__F_101799" - N_101764__F_101767 => N_101764__F_101805 - N_101764__F_101767 => "N_101764__F_101836" - N_101764__F_101767 => "N_101764__F_101846" - N_101764__F_101767 => "N_101764__F_101856" - N_101764__F_101767 => "N_101764__I_101839_i_F_101837" - N_101764__F_101767 => "N_101764__I_101849_i_F_101847" - N_101764__F_101767 => "N_101764__I_101859_i_F_101857" - N_101764__F_101767 => N_101764__I_101839_i_F_101840 - N_101764__F_101767 => N_101764__I_101849_i_F_101850 - N_101764__F_101767 => N_101764__I_101859_i_F_101860 - N_101764__F_101767 => N_101764__I_101816_i_F_101820 - N_101764__F_101767 => N_101764__I_101870_i_F_101871 - N_101764__F_101767 => N_101764__I_101870_i_F_101874 - N_101764__F_101767 => N_101764__I_101883_i_F_101884 - N_101764__F_101767 => N_101764__I_101883_i_F_101887 - N_101764__F_101767 => N_101764__I_101896_i_F_101897 - N_101764__F_101767 => N_101764__I_101896_i_F_101900 - N_101764__F_101767 => "N_101764__F_101866" - N_101764__F_101767 => "N_101764__F_101867" - N_101764__F_101767 => "N_101764__I_101870_i_F_101868" - N_101764__F_101767 => "N_101764__F_101880" - N_101764__F_101767 => "N_101764__I_101883_i_F_101881" - N_101764__F_101767 => "N_101764__F_101893" - N_101764__F_101767 => "N_101764__I_101896_i_F_101894" - N_101764__F_101768 => "N_101764__F_101783" - N_101764__F_101768 => "N_101764__F_101793" - N_101764__F_101768 => "N_101764__F_101808" - N_101764__F_101768 => N_101764__F_101809 - N_101764__F_101768 => "N_101764__F_101807" - N_101764__F_101768 => "N_101764__F_101810" - N_101764__F_101768 => "N_101764__I_101816_i_F_101814" - N_101764__F_101768 => N_101764__I_101816_i_F_101823 - N_101764__F_101768 => "N_101764__F_101835" - N_101764__F_101768 => "N_101764__F_101836" - N_101764__F_101768 => "N_101764__I_101839_i_F_101837" - N_101764__F_101768 => N_101764__I_101839_i_F_101840 - N_101764__F_101768 => "N_101764__F_101846" - N_101764__F_101768 => "N_101764__I_101849_i_F_101847" - N_101764__F_101768 => N_101764__I_101849_i_F_101850 - N_101764__F_101768 => "N_101764__F_101856" - N_101764__F_101768 => "N_101764__I_101859_i_F_101857" - N_101764__F_101768 => N_101764__I_101859_i_F_101860 - N_101764__F_101768 => N_101764__I_101870_i_F_101871 - N_101764__F_101768 => N_101764__I_101870_i_F_101874 - N_101764__F_101768 => N_101764__I_101883_i_F_101884 - N_101764__F_101768 => N_101764__I_101883_i_F_101887 - N_101764__F_101768 => N_101764__I_101896_i_F_101897 - N_101764__F_101768 => N_101764__I_101896_i_F_101900 - N_101764__F_101768 => "N_101764__F_101867" - N_101764__F_101768 => "N_101764__I_101870_i_F_101868" - N_101764__F_101768 => "N_101764__F_101880" - N_101764__F_101768 => "N_101764__I_101883_i_F_101881" - N_101764__F_101768 => "N_101764__F_101893" - N_101764__F_101768 => "N_101764__I_101896_i_F_101894" - N_101764__F_101768 => "N_101764__F_101866" - N_101764__F_101769 => "N_101764__F_101807" - N_101764__F_101769 => "N_101764__F_101783" - N_101764__F_101769 => "N_101764__F_101793" - N_101764__F_101769 => "N_101764__F_101810" - N_101764__F_101769 => "N_101764__F_101835" - N_101764__F_101769 => "N_101764__F_101808" - N_101764__F_101769 => N_101764__F_101809 - N_101764__F_101769 => "N_101764__F_101836" - N_101764__F_101769 => "N_101764__F_101846" - N_101764__F_101769 => "N_101764__F_101856" - N_101764__F_101769 => "N_101764__I_101839_i_F_101837" - N_101764__F_101769 => "N_101764__I_101849_i_F_101847" - N_101764__F_101769 => "N_101764__I_101859_i_F_101857" - N_101764__F_101769 => N_101764__I_101839_i_F_101840 - N_101764__F_101769 => N_101764__I_101849_i_F_101850 - N_101764__F_101769 => N_101764__I_101859_i_F_101860 - N_101764__F_101769 => N_101764__I_101816_i_F_101823 - N_101764__F_101769 => N_101764__I_101870_i_F_101871 - N_101764__F_101769 => N_101764__I_101870_i_F_101874 - N_101764__F_101769 => N_101764__I_101883_i_F_101884 - N_101764__F_101769 => N_101764__I_101883_i_F_101887 - N_101764__F_101769 => N_101764__I_101896_i_F_101897 - N_101764__F_101769 => N_101764__I_101896_i_F_101900 - N_101764__F_101769 => "N_101764__F_101866" - N_101764__F_101769 => "N_101764__F_101867" - N_101764__F_101769 => "N_101764__I_101870_i_F_101868" - N_101764__F_101769 => "N_101764__F_101880" - N_101764__F_101769 => "N_101764__I_101883_i_F_101881" - N_101764__F_101769 => "N_101764__F_101893" - N_101764__F_101769 => "N_101764__I_101896_i_F_101894" - N_101764__F_101770 => "N_101764__F_101783" - N_101764__F_101770 => "N_101764__F_101793" - N_101764__F_101770 => "N_101764__F_101807" - N_101764__F_101770 => "N_101764__F_101808" - N_101764__F_101770 => N_101764__F_101809 - N_101764__F_101770 => "N_101764__F_101810" - N_101764__F_101770 => "N_101764__I_101816_i_F_101814" - N_101764__F_101770 => N_101764__I_101816_i_F_101823 - N_101764__F_101770 => "N_101764__F_101835" - N_101764__F_101770 => "N_101764__F_101836" - N_101764__F_101770 => "N_101764__I_101839_i_F_101837" - N_101764__F_101770 => N_101764__I_101839_i_F_101840 - N_101764__F_101770 => "N_101764__F_101846" - N_101764__F_101770 => "N_101764__I_101849_i_F_101847" - N_101764__F_101770 => N_101764__I_101849_i_F_101850 - N_101764__F_101770 => "N_101764__F_101856" - N_101764__F_101770 => "N_101764__I_101859_i_F_101857" - N_101764__F_101770 => N_101764__I_101859_i_F_101860 - N_101764__F_101770 => N_101764__I_101870_i_F_101871 - N_101764__F_101770 => N_101764__I_101870_i_F_101874 - N_101764__F_101770 => N_101764__I_101883_i_F_101884 - N_101764__F_101770 => N_101764__I_101883_i_F_101887 - N_101764__F_101770 => N_101764__I_101896_i_F_101897 - N_101764__F_101770 => N_101764__I_101896_i_F_101900 - N_101764__F_101770 => "N_101764__F_101866" - N_101764__F_101770 => "N_101764__F_101867" - N_101764__F_101770 => "N_101764__I_101870_i_F_101868" - N_101764__F_101770 => "N_101764__F_101880" - N_101764__F_101770 => "N_101764__I_101883_i_F_101881" - N_101764__F_101770 => "N_101764__F_101893" - N_101764__F_101770 => "N_101764__I_101896_i_F_101894" - N_101764__F_101771 => "N_101764__F_101798" - N_101764__F_101771 => "N_101764__F_101783" - N_101764__F_101771 => "N_101764__F_101793" - N_101764__F_101771 => "N_101764__F_101799" - N_101764__F_101771 => N_101764__F_101800 - N_101764__F_101771 => "N_101764__F_101810" - N_101764__F_101771 => "N_101764__F_101835" - N_101764__F_101771 => "N_101764__F_101836" - N_101764__F_101771 => "N_101764__F_101846" - N_101764__F_101771 => "N_101764__F_101856" - N_101764__F_101771 => "N_101764__I_101839_i_F_101837" - N_101764__F_101771 => "N_101764__I_101849_i_F_101847" - N_101764__F_101771 => "N_101764__I_101859_i_F_101857" - N_101764__F_101771 => N_101764__I_101839_i_F_101840 - N_101764__F_101771 => N_101764__I_101849_i_F_101850 - N_101764__F_101771 => N_101764__I_101859_i_F_101860 - N_101764__F_101771 => N_101764__I_101816_i_F_101832 - N_101764__F_101771 => N_101764__I_101870_i_F_101871 - N_101764__F_101771 => N_101764__I_101870_i_F_101874 - N_101764__F_101771 => N_101764__I_101883_i_F_101884 - N_101764__F_101771 => N_101764__I_101883_i_F_101887 - N_101764__F_101771 => N_101764__I_101896_i_F_101897 - N_101764__F_101771 => N_101764__I_101896_i_F_101900 - N_101764__F_101771 => "N_101764__F_101866" - N_101764__F_101771 => "N_101764__F_101867" - N_101764__F_101771 => "N_101764__I_101870_i_F_101868" - N_101764__F_101771 => "N_101764__F_101880" - N_101764__F_101771 => "N_101764__I_101883_i_F_101881" - N_101764__F_101771 => "N_101764__F_101893" - N_101764__F_101771 => "N_101764__I_101896_i_F_101894" - N_101764__F_101772 => N_101764__I_101816_i_F_101817 - N_101764__F_101772 => N_101764__F_101803 - N_101764__F_101772 => N_101764__I_101839_i_F_101840 - N_101764__F_101772 => N_101764__I_101849_i_F_101850 - N_101764__F_101772 => N_101764__I_101859_i_F_101860 - N_101764__F_101772 => "N_101764__F_101783" - N_101764__F_101772 => "N_101764__F_101793" - N_101764__F_101772 => "N_101764__F_101798" - N_101764__F_101772 => "N_101764__F_101810" - N_101764__F_101772 => "N_101764__I_101816_i_F_101814" - N_101764__F_101772 => "N_101764__F_101835" - N_101764__F_101772 => "N_101764__I_101839_i_F_101837" - N_101764__F_101772 => "N_101764__I_101859_i_F_101857" - N_101764__F_101772 => "N_101764__F_101836" - N_101764__F_101772 => "N_101764__I_101849_i_F_101847" - N_101764__F_101772 => "N_101764__F_101846" - N_101764__F_101772 => "N_101764__F_101856" - N_101764__F_101772 => N_101764__I_101870_i_F_101871 - N_101764__F_101772 => N_101764__I_101870_i_F_101874 - N_101764__F_101772 => N_101764__I_101883_i_F_101884 - N_101764__F_101772 => N_101764__I_101883_i_F_101887 - N_101764__F_101772 => N_101764__I_101896_i_F_101897 - N_101764__F_101772 => N_101764__I_101896_i_F_101900 - N_101764__F_101772 => "N_101764__F_101866" - N_101764__F_101772 => "N_101764__F_101867" - N_101764__F_101772 => "N_101764__I_101870_i_F_101868" - N_101764__F_101772 => "N_101764__F_101880" - N_101764__F_101772 => "N_101764__I_101883_i_F_101881" - N_101764__F_101772 => "N_101764__F_101893" - N_101764__F_101772 => "N_101764__I_101896_i_F_101894" - N_101764__F_101773 => "N_101764__F_101783" - N_101764__F_101773 => "N_101764__F_101793" - N_101764__F_101773 => "N_101764__F_101798" - N_101764__F_101773 => "N_101764__F_101799" - N_101764__F_101773 => N_101764__F_101803 - N_101764__F_101773 => "N_101764__F_101835" - N_101764__F_101773 => "N_101764__F_101836" - N_101764__F_101773 => "N_101764__I_101839_i_F_101837" - N_101764__F_101773 => N_101764__I_101839_i_F_101840 - N_101764__F_101773 => "N_101764__F_101846" - N_101764__F_101773 => "N_101764__I_101849_i_F_101847" - N_101764__F_101773 => N_101764__I_101849_i_F_101850 - N_101764__F_101773 => "N_101764__F_101856" - N_101764__F_101773 => "N_101764__I_101859_i_F_101857" - N_101764__F_101773 => N_101764__I_101859_i_F_101860 - N_101764__F_101773 => N_101764__I_101870_i_F_101871 - N_101764__F_101773 => N_101764__I_101870_i_F_101874 - N_101764__F_101773 => N_101764__I_101883_i_F_101884 - N_101764__F_101773 => N_101764__I_101883_i_F_101887 - N_101764__F_101773 => N_101764__I_101896_i_F_101897 - N_101764__F_101773 => N_101764__I_101896_i_F_101900 - N_101764__F_101773 => "N_101764__F_101866" - N_101764__F_101773 => "N_101764__F_101867" - N_101764__F_101773 => "N_101764__I_101870_i_F_101868" - N_101764__F_101773 => "N_101764__F_101880" - N_101764__F_101773 => "N_101764__I_101883_i_F_101881" - N_101764__F_101773 => "N_101764__F_101893" - N_101764__F_101773 => "N_101764__I_101896_i_F_101894" - N_101764__F_101773 => "N_101764__F_101810" - N_101764__F_101773 => "N_101764__I_101816_i_F_101814" - N_101764__F_101774 => "N_101764__F_101784" - N_101764__F_101774 => N_101764__F_101787 - N_101764__F_101774 => N_101764__F_101813 - N_101764__F_101774 => "N_101764__F_101783" - N_101764__F_101774 => "N_101764__F_101785" - N_101764__F_101774 => "N_101764__F_101810" - N_101764__F_101774 => "N_101764__F_101811" - N_101764__F_101774 => N_101764__F_101813 - N_101764__F_101774 => "N_101764__F_101835" - N_101764__F_101774 => "N_101764__F_101836" - N_101764__F_101774 => "N_101764__F_101846" - N_101764__F_101774 => "N_101764__F_101856" - N_101764__F_101774 => "N_101764__I_101839_i_F_101837" - N_101764__F_101774 => "N_101764__I_101849_i_F_101847" - N_101764__F_101774 => "N_101764__I_101859_i_F_101857" - N_101764__F_101774 => N_101764__I_101839_i_F_101840 - N_101764__F_101774 => N_101764__I_101849_i_F_101850 - N_101764__F_101774 => N_101764__I_101859_i_F_101860 - N_101764__F_101774 => N_101764__I_101859_i_F_101863 - N_101764__F_101774 => N_101764__F_101792 - N_101764__F_101774 => N_101764__I_101870_i_F_101871 - N_101764__F_101774 => N_101764__I_101870_i_F_101874 - N_101764__F_101774 => N_101764__I_101883_i_F_101884 - N_101764__F_101774 => N_101764__I_101883_i_F_101887 - N_101764__F_101774 => N_101764__I_101896_i_F_101897 - N_101764__F_101774 => N_101764__I_101896_i_F_101900 - N_101764__F_101774 => "N_101764__F_101866" - N_101764__F_101774 => "N_101764__F_101867" - N_101764__F_101774 => "N_101764__I_101870_i_F_101868" - N_101764__F_101774 => "N_101764__F_101880" - N_101764__F_101774 => "N_101764__I_101883_i_F_101881" - N_101764__F_101774 => "N_101764__F_101893" - N_101764__F_101774 => "N_101764__I_101896_i_F_101894" - N_101764__F_101775 => "N_101764__F_101784" - N_101764__F_101775 => "N_101764__F_101810" - N_101764__F_101775 => "N_101764__F_101811" - N_101764__F_101775 => "N_101764__F_101835" - N_101764__F_101775 => "N_101764__F_101836" - N_101764__F_101775 => "N_101764__F_101846" - N_101764__F_101775 => "N_101764__I_101839_i_F_101837" - N_101764__F_101775 => "N_101764__I_101849_i_F_101847" - N_101764__F_101775 => N_101764__I_101839_i_F_101840 - N_101764__F_101775 => N_101764__I_101849_i_F_101850 - N_101764__F_101775 => "N_101764__F_101783" - N_101764__F_101775 => N_101764__F_101788 - N_101764__F_101775 => "N_101764__F_101785" - N_101764__F_101775 => N_101764__I_101870_i_F_101871 - N_101764__F_101775 => N_101764__I_101870_i_F_101874 - N_101764__F_101775 => N_101764__I_101883_i_F_101884 - N_101764__F_101775 => N_101764__I_101883_i_F_101887 - N_101764__F_101775 => N_101764__I_101896_i_F_101897 - N_101764__F_101775 => N_101764__I_101896_i_F_101900 - N_101764__F_101775 => "N_101764__F_101866" - N_101764__F_101775 => "N_101764__F_101867" - N_101764__F_101775 => "N_101764__I_101870_i_F_101868" - N_101764__F_101775 => "N_101764__F_101880" - N_101764__F_101775 => "N_101764__I_101883_i_F_101881" - N_101764__F_101775 => "N_101764__F_101893" - N_101764__F_101775 => "N_101764__I_101896_i_F_101894" - N_101764__F_101776 => "N_101764__F_101784" - N_101764__F_101776 => "N_101764__F_101810" - N_101764__F_101776 => "N_101764__F_101811" - N_101764__F_101776 => "N_101764__F_101835" - N_101764__F_101776 => "N_101764__F_101836" - N_101764__F_101776 => "N_101764__F_101846" - N_101764__F_101776 => "N_101764__I_101839_i_F_101837" - N_101764__F_101776 => "N_101764__I_101849_i_F_101847" - N_101764__F_101776 => N_101764__I_101839_i_F_101840 - N_101764__F_101776 => N_101764__I_101849_i_F_101850 - N_101764__F_101776 => "N_101764__F_101783" - N_101764__F_101776 => N_101764__F_101789 - N_101764__F_101776 => "N_101764__F_101785" - N_101764__F_101776 => N_101764__I_101870_i_F_101871 - N_101764__F_101776 => N_101764__I_101870_i_F_101874 - N_101764__F_101776 => N_101764__I_101883_i_F_101884 - N_101764__F_101776 => N_101764__I_101883_i_F_101887 - N_101764__F_101776 => N_101764__I_101896_i_F_101897 - N_101764__F_101776 => N_101764__I_101896_i_F_101900 - N_101764__F_101776 => "N_101764__F_101866" - N_101764__F_101776 => "N_101764__F_101867" - N_101764__F_101776 => "N_101764__I_101870_i_F_101868" - N_101764__F_101776 => "N_101764__F_101880" - N_101764__F_101776 => "N_101764__I_101883_i_F_101881" - N_101764__F_101776 => "N_101764__F_101893" - N_101764__F_101776 => "N_101764__I_101896_i_F_101894" - N_101764__F_101777 => "N_101764__F_101784" - N_101764__F_101777 => "N_101764__F_101810" - N_101764__F_101777 => "N_101764__F_101811" - N_101764__F_101777 => "N_101764__F_101835" - N_101764__F_101777 => "N_101764__F_101836" - N_101764__F_101777 => "N_101764__F_101846" - N_101764__F_101777 => "N_101764__F_101856" - N_101764__F_101777 => "N_101764__I_101839_i_F_101837" - N_101764__F_101777 => "N_101764__I_101849_i_F_101847" - N_101764__F_101777 => "N_101764__I_101859_i_F_101857" - N_101764__F_101777 => N_101764__I_101839_i_F_101840 - N_101764__F_101777 => N_101764__I_101849_i_F_101850 - N_101764__F_101777 => "N_101764__F_101783" - N_101764__F_101777 => "N_101764__F_101785" - N_101764__F_101777 => N_101764__F_101790 - N_101764__F_101777 => N_101764__F_101812 - N_101764__F_101777 => N_101764__I_101859_i_F_101860 - N_101764__F_101777 => N_101764__F_101792 - N_101764__F_101777 => N_101764__I_101870_i_F_101871 - N_101764__F_101777 => N_101764__I_101870_i_F_101874 - N_101764__F_101777 => N_101764__I_101883_i_F_101884 - N_101764__F_101777 => N_101764__I_101883_i_F_101887 - N_101764__F_101777 => N_101764__I_101896_i_F_101897 - N_101764__F_101777 => N_101764__I_101896_i_F_101900 - N_101764__F_101777 => "N_101764__F_101866" - N_101764__F_101777 => "N_101764__F_101867" - N_101764__F_101777 => "N_101764__I_101870_i_F_101868" - N_101764__F_101777 => "N_101764__F_101880" - N_101764__F_101777 => "N_101764__I_101883_i_F_101881" - N_101764__F_101777 => "N_101764__F_101893" - N_101764__F_101777 => "N_101764__I_101896_i_F_101894" - N_101764__F_101778 => "N_101764__F_101783" - N_101764__F_101778 => "N_101764__F_101784" - N_101764__F_101778 => "N_101764__F_101785" - N_101764__F_101778 => N_101764__F_101786 - N_101764__F_101778 => "N_101764__F_101810" - N_101764__F_101778 => "N_101764__F_101811" - N_101764__F_101778 => N_101764__F_101812 - N_101764__F_101778 => "N_101764__F_101835" - N_101764__F_101778 => "N_101764__F_101856" - N_101764__F_101778 => "N_101764__I_101859_i_F_101857" - N_101764__F_101778 => N_101764__I_101859_i_F_101860 - N_101764__F_101778 => N_101764__I_101870_i_F_101871 - N_101764__F_101778 => N_101764__I_101870_i_F_101874 - N_101764__F_101778 => N_101764__I_101883_i_F_101884 - N_101764__F_101778 => N_101764__I_101883_i_F_101887 - N_101764__F_101778 => N_101764__I_101896_i_F_101897 - N_101764__F_101778 => N_101764__I_101896_i_F_101900 - N_101764__F_101778 => "N_101764__F_101866" - N_101764__F_101778 => "N_101764__F_101867" - N_101764__F_101778 => "N_101764__I_101870_i_F_101868" - N_101764__F_101778 => "N_101764__F_101880" - N_101764__F_101778 => "N_101764__I_101883_i_F_101881" - N_101764__F_101778 => "N_101764__F_101893" - N_101764__F_101778 => "N_101764__I_101896_i_F_101894" - N_101764__F_101779 => "N_101764__F_101783" - N_101764__F_101779 => "N_101764__F_101784" - N_101764__F_101779 => "N_101764__F_101785" - N_101764__F_101779 => N_101764__F_101790 - N_101764__F_101779 => N_101764__F_101792 - N_101764__F_101779 => "N_101764__F_101810" - N_101764__F_101779 => "N_101764__F_101811" - N_101764__F_101779 => N_101764__F_101812 - N_101764__F_101779 => "N_101764__F_101835" - N_101764__F_101779 => "N_101764__F_101836" - N_101764__F_101779 => "N_101764__I_101839_i_F_101837" - N_101764__F_101779 => N_101764__I_101839_i_F_101840 - N_101764__F_101779 => "N_101764__F_101846" - N_101764__F_101779 => "N_101764__I_101849_i_F_101847" - N_101764__F_101779 => N_101764__I_101849_i_F_101850 - N_101764__F_101779 => "N_101764__F_101856" - N_101764__F_101779 => "N_101764__I_101859_i_F_101857" - N_101764__F_101779 => N_101764__I_101859_i_F_101860 - N_101764__F_101779 => N_101764__I_101870_i_F_101871 - N_101764__F_101779 => N_101764__I_101870_i_F_101874 - N_101764__F_101779 => N_101764__I_101883_i_F_101884 - N_101764__F_101779 => N_101764__I_101883_i_F_101887 - N_101764__F_101779 => N_101764__I_101896_i_F_101897 - N_101764__F_101779 => N_101764__I_101896_i_F_101900 - N_101764__F_101779 => "N_101764__F_101866" - N_101764__F_101779 => "N_101764__F_101867" - N_101764__F_101779 => "N_101764__I_101870_i_F_101868" - N_101764__F_101779 => "N_101764__F_101880" - N_101764__F_101779 => "N_101764__I_101883_i_F_101881" - N_101764__F_101779 => "N_101764__F_101893" - N_101764__F_101779 => "N_101764__I_101896_i_F_101894" - N_101764__F_101780 => "N_101764__F_101783" - N_101764__F_101780 => "N_101764__F_101784" - N_101764__F_101780 => "N_101764__F_101785" - N_101764__F_101780 => N_101764__F_101786 - N_101764__F_101780 => N_101764__F_101792 - N_101764__F_101780 => "N_101764__F_101810" - N_101764__F_101780 => "N_101764__F_101811" - N_101764__F_101780 => N_101764__F_101812 - N_101764__F_101780 => "N_101764__F_101835" - N_101764__F_101780 => "N_101764__F_101856" - N_101764__F_101780 => "N_101764__I_101859_i_F_101857" - N_101764__F_101780 => N_101764__I_101859_i_F_101860 - N_101764__F_101780 => N_101764__I_101870_i_F_101871 - N_101764__F_101780 => N_101764__I_101870_i_F_101874 - N_101764__F_101780 => N_101764__I_101883_i_F_101884 - N_101764__F_101780 => N_101764__I_101883_i_F_101887 - N_101764__F_101780 => N_101764__I_101896_i_F_101897 - N_101764__F_101780 => N_101764__I_101896_i_F_101900 - N_101764__F_101780 => "N_101764__F_101866" - N_101764__F_101780 => "N_101764__F_101867" - N_101764__F_101780 => "N_101764__I_101870_i_F_101868" - N_101764__F_101780 => "N_101764__F_101880" - N_101764__F_101780 => "N_101764__I_101883_i_F_101881" - N_101764__F_101780 => "N_101764__F_101893" - N_101764__F_101780 => "N_101764__I_101896_i_F_101894" - N_101764__F_101781 => "N_101764__F_101783" - N_101764__F_101781 => "N_101764__F_101784" - N_101764__F_101781 => "N_101764__F_101785" - N_101764__F_101781 => "N_101764__F_101785" - N_101764__F_101781 => N_101764__F_101787 - N_101764__F_101781 => N_101764__F_101792 - N_101764__F_101781 => "N_101764__F_101810" - N_101764__F_101781 => "N_101764__F_101811" - N_101764__F_101781 => N_101764__F_101813 - N_101764__F_101781 => "N_101764__F_101835" - N_101764__F_101781 => "N_101764__F_101836" - N_101764__F_101781 => "N_101764__I_101839_i_F_101837" - N_101764__F_101781 => N_101764__I_101839_i_F_101840 - N_101764__F_101781 => "N_101764__F_101846" - N_101764__F_101781 => "N_101764__I_101849_i_F_101847" - N_101764__F_101781 => N_101764__I_101849_i_F_101850 - N_101764__F_101781 => "N_101764__F_101856" - N_101764__F_101781 => "N_101764__I_101859_i_F_101857" - N_101764__F_101781 => N_101764__I_101859_i_F_101860 - N_101764__F_101781 => N_101764__I_101870_i_F_101871 - N_101764__F_101781 => N_101764__I_101870_i_F_101874 - N_101764__F_101781 => N_101764__I_101883_i_F_101884 - N_101764__F_101781 => N_101764__I_101883_i_F_101887 - N_101764__F_101781 => N_101764__I_101896_i_F_101897 - N_101764__F_101781 => N_101764__I_101896_i_F_101900 - N_101764__F_101781 => "N_101764__F_101866" - N_101764__F_101781 => "N_101764__F_101867" - N_101764__F_101781 => "N_101764__I_101870_i_F_101868" - N_101764__F_101781 => "N_101764__F_101880" - N_101764__F_101781 => "N_101764__I_101883_i_F_101881" - N_101764__F_101781 => "N_101764__F_101893" - N_101764__F_101781 => "N_101764__I_101896_i_F_101894" - N_101764__F_101782 => "N_101764__F_101783" - N_101764__F_101782 => "N_101764__F_101793" - N_101764__F_101782 => "N_101764__F_101794" - N_101764__F_101782 => "N_101764__F_101795" - N_101764__F_101782 => N_101764__F_101797 - N_101764__F_101782 => "N_101764__F_101810" - N_101764__F_101782 => "N_101764__I_101816_i_F_101814" - N_101764__F_101782 => N_101764__I_101816_i_F_101820 - N_101764__F_101782 => "N_101764__F_101835" - N_101764__F_101782 => "N_101764__I_101839_i_F_101837" - N_101764__F_101782 => N_101764__I_101839_i_F_101840 - N_101764__F_101782 => "N_101764__F_101846" - N_101764__F_101782 => "N_101764__I_101849_i_F_101847" - N_101764__F_101782 => N_101764__I_101849_i_F_101850 - N_101764__F_101782 => "N_101764__F_101856" - N_101764__F_101782 => "N_101764__I_101859_i_F_101857" - N_101764__F_101782 => N_101764__I_101859_i_F_101860 - N_101764__F_101782 => N_101764__I_101870_i_F_101871 - N_101764__F_101782 => N_101764__I_101870_i_F_101874 - N_101764__F_101782 => N_101764__I_101883_i_F_101884 - N_101764__F_101782 => N_101764__I_101883_i_F_101887 - N_101764__F_101782 => N_101764__I_101896_i_F_101897 - N_101764__F_101782 => N_101764__I_101896_i_F_101900 - N_101764__F_101782 => "N_101764__F_101866" - N_101764__F_101782 => "N_101764__F_101867" - N_101764__F_101782 => "N_101764__I_101870_i_F_101868" - N_101764__F_101782 => "N_101764__F_101880" - N_101764__F_101782 => "N_101764__I_101883_i_F_101881" - N_101764__F_101782 => "N_101764__F_101893" - N_101764__F_101782 => "N_101764__I_101896_i_F_101894" - N_101906__F_101909 => N_101906__F_101913 - N_101906__F_101909 => N_101906__F_101926 - N_101906__F_101909 => N_101906__F_101928 - N_101906__F_101910 => "N_101906__F_101915" - N_101906__F_101910 => N_101906__F_101926 - N_101906__F_101910 => N_101906__F_101928 - N_101906__F_101910 => N_101906__F_101916 - N_101906__F_101911 => N_101906__F_101913 - N_101906__F_101911 => N_101906__F_101926 - N_101906__F_101911 => N_101906__F_101928 - N_101906__F_101928 => N_104357__F_104385 - N_101906__F_101930 => N_100618__F_100708 - N_101906__F_101931 => N_100618__F_100709 - N_101932__F_101935 => "N_101932__F_101946" - N_101932__F_101935 => "N_101932__F_101954" - N_101932__F_101935 => N_101932__F_101961 - N_101932__F_101935 => "N_101932__F_101964" - N_101932__F_101935 => "N_101932__F_101986" - N_101932__F_101935 => N_101932__I_101967_i_F_101968 - N_101932__F_101935 => N_101932__F_101955 - N_101932__F_101935 => N_101932__I_101993_i_F_101994 - N_101932__F_101935 => N_101932__I_101993_i_F_101997 - N_101932__F_101935 => "N_101932__F_101990" - N_101932__F_101935 => "N_101932__I_101993_i_F_101991" - N_101932__F_101936 => "N_101932__F_101946" - N_101932__F_101936 => "N_101932__F_101954" - N_101932__F_101936 => N_101932__F_101957 - N_101932__F_101936 => "N_101932__F_101964" - N_101932__F_101936 => "N_101932__F_101986" - N_101932__F_101936 => N_101932__I_101967_i_F_101968 - N_101932__F_101936 => N_101932__F_101955 - N_101932__F_101936 => N_101932__I_101993_i_F_101994 - N_101932__F_101936 => N_101932__I_101993_i_F_101997 - N_101932__F_101936 => "N_101932__F_101990" - N_101932__F_101936 => "N_101932__I_101993_i_F_101991" - N_101932__F_101937 => "N_101932__F_101946" - N_101932__F_101937 => "N_101932__F_101954" - N_101932__F_101937 => N_101932__F_101959 - N_101932__F_101937 => "N_101932__F_101964" - N_101932__F_101937 => "N_101932__F_101986" - N_101932__F_101937 => N_101932__I_101967_i_F_101968 - N_101932__F_101937 => N_101932__F_101955 - N_101932__F_101937 => N_101932__I_101993_i_F_101994 - N_101932__F_101937 => N_101932__I_101993_i_F_101997 - N_101932__F_101937 => "N_101932__F_101990" - N_101932__F_101937 => "N_101932__I_101993_i_F_101991" - N_101932__F_101938 => "N_101932__F_101946" - N_101932__F_101938 => "N_101932__F_101954" - N_101932__F_101938 => N_101932__F_101955 - N_101932__F_101938 => N_101932__F_101956 - N_101932__F_101938 => "N_101932__F_101964" - N_101932__F_101938 => "N_101932__I_101967_i_F_101965" - N_101932__F_101938 => N_101932__I_101967_i_F_101968 - N_101932__F_101938 => N_101932__I_101993_i_F_101994 - N_101932__F_101938 => N_101932__I_101993_i_F_101997 - N_101932__F_101938 => "N_101932__F_101990" - N_101932__F_101938 => "N_101932__I_101993_i_F_101991" - N_101932__F_101939 => "N_101932__F_101946" - N_101932__F_101939 => "N_101932__F_101954" - N_101932__F_101939 => N_101932__F_101956 - N_101932__F_101939 => "N_101932__F_101964" - N_101932__F_101939 => "N_101932__F_101986" - N_101932__F_101939 => N_101932__I_101967_i_F_101974 - N_101932__F_101939 => N_101932__I_101993_i_F_101994 - N_101932__F_101939 => N_101932__I_101993_i_F_101997 - N_101932__F_101939 => "N_101932__F_101990" - N_101932__F_101939 => "N_101932__I_101993_i_F_101991" - N_101932__F_101940 => "N_101932__F_101946" - N_101932__F_101940 => "N_101932__F_101954" - N_101932__F_101940 => N_101932__F_101957 - N_101932__F_101940 => "N_101932__F_101964" - N_101932__F_101940 => "N_101932__F_101986" - N_101932__F_101940 => N_101932__I_101967_i_F_101974 - N_101932__F_101940 => N_101932__I_101993_i_F_101994 - N_101932__F_101940 => N_101932__I_101993_i_F_101997 - N_101932__F_101940 => "N_101932__F_101990" - N_101932__F_101940 => "N_101932__I_101993_i_F_101991" - N_101932__F_101941 => "N_101932__F_101946" - N_101932__F_101941 => "N_101932__F_101954" - N_101932__F_101941 => N_101932__F_101955 - N_101932__F_101941 => "N_101932__F_101964" - N_101932__F_101941 => "N_101932__I_101967_i_F_101965" - N_101932__F_101941 => N_101932__I_101967_i_F_101968 - N_101932__F_101941 => N_101932__I_101993_i_F_101994 - N_101932__F_101941 => N_101932__I_101993_i_F_101997 - N_101932__F_101941 => "N_101932__F_101990" - N_101932__F_101941 => "N_101932__I_101993_i_F_101991" - N_101932__F_101942 => "N_101932__F_101946" - N_101932__F_101942 => "N_101932__F_101954" - N_101932__F_101942 => N_101932__F_101962 - N_101932__F_101942 => "N_101932__F_101964" - N_101932__F_101942 => "N_101932__F_101986" - N_101932__F_101942 => N_101932__I_101967_i_F_101977 - N_101932__F_101942 => N_101932__F_101955 - N_101932__F_101942 => N_101932__I_101993_i_F_101994 - N_101932__F_101942 => N_101932__I_101993_i_F_101997 - N_101932__F_101942 => "N_101932__F_101990" - N_101932__F_101942 => "N_101932__I_101993_i_F_101991" - N_101932__F_101943 => "N_101932__F_101946" - N_101932__F_101943 => "N_101932__F_101954" - N_101932__F_101943 => N_101932__F_101955 - N_101932__F_101943 => "N_101932__F_101964" - N_101932__F_101943 => "N_101932__I_101967_i_F_101965" - N_101932__F_101943 => N_101932__I_101993_i_F_101994 - N_101932__F_101943 => N_101932__I_101993_i_F_101997 - N_101932__F_101943 => "N_101932__F_101990" - N_101932__F_101943 => "N_101932__I_101993_i_F_101991" - N_101932__F_101944 => "N_101932__F_101946" - N_101932__F_101944 => "N_101932__F_101947" - N_101932__F_101944 => N_101932__F_101949 - N_101932__F_101944 => "N_101932__F_101964" - N_101932__F_101944 => "N_101932__F_101986" - N_101932__F_101944 => "N_101932__F_101987" - N_101932__F_101944 => N_101932__I_101967_i_F_101968 - N_101932__F_101944 => N_101932__F_101948 - N_101932__F_101944 => N_101932__I_101993_i_F_102000 - N_101932__F_101944 => "N_101932__F_101990" - N_101932__F_101944 => "N_101932__I_101993_i_F_101991" - N_101932__F_101945 => "N_101932__F_101946" - N_101932__F_101945 => "N_101932__F_101947" - N_101932__F_101945 => N_101932__F_101948 - N_101932__F_101945 => N_101932__F_101950 - N_101932__F_101945 => "N_101932__F_101964" - N_101932__F_101945 => "N_101932__I_101967_i_F_101965" - N_101932__F_101945 => N_101932__I_101967_i_F_101968 - N_101932__F_101945 => "N_101932__F_101986" - N_101932__F_101945 => "N_101932__F_101987" - N_101932__F_101945 => N_101932__F_101988 - N_101932__F_101945 => N_101932__I_101993_i_F_102000 - N_101932__F_101945 => "N_101932__F_101990" - N_101932__F_101945 => "N_101932__I_101993_i_F_101991" - N_102004__F_102007 => N_102004__F_102015 - N_102004__F_102007 => N_102004__F_102017 - N_102004__F_102007 => "N_102004__F_102019" - N_102004__F_102007 => N_102004__F_102020 - N_102004__F_102007 => N_102004__F_102022 - N_102004__F_102007 => N_102004__F_102025 - N_102004__F_102007 => "N_100300__F_100330" - N_102004__F_102007 => N_104357__F_104387 - N_102004__F_102008 => N_100300__F_100326 - N_102004__F_102008 => N_102004__F_102015 - N_102004__F_102008 => N_102004__F_102017 - N_102004__F_102008 => N_102004__F_102020 - N_102004__F_102008 => N_102004__F_102022 - !(N_102004__F_102008 & "N_102004__F_102023") - N_102004__F_102008 => "N_102004__F_102019" - N_102004__F_102008 => N_104357__F_104388 - N_102004__F_102009 => N_102004__F_102012 - N_102004__F_102009 => N_102004__F_102017 - N_102004__F_102009 => N_102004__F_102022 - N_102004__F_102009 => "N_100300__F_100330" - N_102004__F_102009 => N_102004__F_102020 - !(N_102004__F_102009 & "N_102004__F_102023") - N_104284__F_104287 => N_104284__F_104296 - N_104284__F_104287 => N_104284__F_104302 - N_104284__F_104287 => N_104284__F_104310 - !(N_104284__F_104287 & "N_104284__F_104311") - N_104284__F_104287 => N_104284__F_104329 - N_104284__F_104287 => N_104284__F_104331 - N_104284__F_104287 => N_104284__F_104333 - N_104284__F_104288 => "N_104284__F_104291" - N_104284__F_104288 => N_104284__F_104309 - N_104284__F_104288 => N_104284__F_104329 - N_104284__F_104288 => N_104284__F_104293 - !(N_104284__F_104288 & "N_104284__F_104311") - N_104284__F_104288 => N_104284__F_104331 - N_104284__F_104288 => N_104284__F_104333 - !("N_104284__F_104311" & "N_104284__F_104297") - N_104334__F_104337 => N_104334__F_104344 - N_104334__F_104337 => N_104334__F_104347 - N_104334__F_104337 => N_104334__F_104351 - N_104334__F_104337 => N_104334__F_104353 - N_104334__F_104338 => N_104334__F_104344 - N_104334__F_104338 => N_104334__F_104347 - N_104334__F_104338 => N_104334__F_104350 - N_104334__F_104338 => N_104334__F_104353 - N_104334__F_104339 => N_104334__F_104344 - N_104334__F_104339 => N_104334__F_104348 - N_104334__F_104339 => N_104334__F_104351 - N_104334__F_104339 => N_104334__F_104353 - N_104334__F_104340 => N_104334__F_104345 - N_104334__F_104340 => N_104334__F_104348 - N_104334__F_104340 => N_104334__F_104350 - N_104334__F_104340 => N_104334__F_104353 - N_104334__F_104341 => N_104334__F_104345 - N_104334__F_104341 => N_104334__F_104354 - "N_104357__F_104521" => N_104357__F_104462 - "N_104357__F_104521" => N_104357__F_104516 - "N_104536__I_104551_i_F_104549" => "N_104649__F_104761" - "N_104536__I_104566_i_F_104564" => "N_104649__F_104775" - "N_104536__I_104581_i_F_104579" => "N_104649__I_104817_i_F_104815" - "N_104536__I_104596_i_F_104594" => "N_104536__F_104639" - "N_104536__I_104596_i_F_104594" => "N_104649__F_104761" - "N_104536__I_104611_i_F_104609" => "N_104536__F_104639" - "N_104536__I_104611_i_F_104609" => "N_104649__F_104775" - "N_104536__I_104626_i_F_104624" => "N_104536__F_104639" - "N_104536__I_104626_i_F_104624" => "N_104649__I_104817_i_F_104815" - N_100576__F_100579 => N_100576__F_100590 - N_100576__F_100579 => N_100576__F_100593 - N_100576__F_100579 => N_100576__F_100597 - N_100576__F_100579 => N_100576__F_100604 - N_100576__F_100579 => N_100576__F_100602 - N_100576__F_100580 => N_100576__F_100591 - N_100576__F_100580 => N_100576__F_100593 - N_100576__F_100580 => N_100576__F_100596 - N_100576__F_100580 => N_100576__F_100604 - N_100576__F_100580 => N_100576__F_100601 - N_100576__F_100581 => N_100576__F_100591 - N_100576__F_100581 => N_100576__F_100594 - N_100576__F_100581 => N_100576__F_100596 - N_100576__F_100581 => N_100576__F_100601 - N_100576__F_100581 => N_100576__F_100604 - N_100576__F_100582 => N_100576__F_100591 - N_100576__F_100582 => N_100576__F_100593 - N_100576__F_100582 => N_100576__F_100596 - N_100576__F_100582 => N_100576__F_100601 - N_100576__F_100582 => N_100576__F_100605 - N_100576__F_100583 => N_100576__F_100591 - N_100576__F_100583 => N_100576__F_100594 - N_100576__F_100583 => N_100576__F_100596 - N_100576__F_100583 => N_100576__F_100601 - N_100576__F_100583 => N_100576__F_100604 - N_100576__F_100584 => N_100576__F_100591 - N_100576__F_100584 => N_100576__F_100594 - N_100576__F_100584 => N_100576__F_100596 - N_100576__F_100584 => N_100576__F_100601 - N_100576__F_100584 => N_100576__F_100605 - N_100576__F_100585 => N_100576__F_100591 - N_100576__F_100585 => N_100576__F_100593 - N_100576__F_100585 => N_100576__F_100598 - N_100576__F_100585 => N_100576__F_100602 - N_100576__F_100585 => N_100576__F_100605 - N_100576__F_100586 => N_100576__F_100591 - N_100576__F_100586 => N_100576__F_100594 - N_100576__F_100586 => N_100576__F_100598 - N_100576__F_100586 => N_100576__F_100600 - N_100576__F_100586 => N_100576__F_100604 - N_100576__F_100587 => N_100576__F_100591 - N_100576__F_100587 => N_100576__F_100594 - N_100576__F_100587 => N_100576__F_100598 - N_100576__F_100587 => N_100576__F_100602 - N_100576__F_100587 => N_100576__F_100605 - N_100618__I_100629_i_F_100630 => "N_104536__I_104551_i_F_104549" - N_100618__I_100629_i_F_100633 => "N_104536__I_104566_i_F_104564" - N_100618__I_100629_i_F_100636 => "N_104536__I_104581_i_F_104579" - N_100618__I_100629_i_F_100639 => "N_104536__I_104596_i_F_104594" - N_100618__I_100629_i_F_100642 => "N_104536__I_104611_i_F_104609" - N_100618__I_100629_i_F_100645 => "N_104536__I_104626_i_F_104624" - N_100618__I_100677_i_F_100678 => "N_104536__I_104551_i_F_104549" - N_100618__I_100677_i_F_100681 => "N_104536__I_104566_i_F_104564" - N_100618__I_100677_i_F_100684 => "N_104536__I_104581_i_F_104579" - N_100618__I_100677_i_F_100687 => "N_104536__I_104596_i_F_104594" - N_100618__I_100677_i_F_100690 => "N_104536__I_104611_i_F_104609" - N_100618__I_100677_i_F_100693 => "N_104536__I_104626_i_F_104624" - N_100000__I_100877_i_F_100881 => N_100000__I_100877_i_F_100920 - N_100000__I_100877_i_F_100884 => N_100000__I_100877_i_F_100938 - N_100000__I_100877_i_F_100887 => N_100000__I_100877_i_F_100938 - N_100000__I_100877_i_F_100890 => N_100000__I_100877_i_F_100935 - !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100920) - !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100923) - !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100926) - !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100935) - !(N_100000__I_100877_i_F_100893 & N_100000__I_100877_i_F_100938) - !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100920) - !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100923) - !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100926) - !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100935) - !(N_100000__I_100877_i_F_100896 & N_100000__I_100877_i_F_100938) - N_100000__I_100877_i_F_100899 => N_100000__I_100877_i_F_100926 - N_100000__I_100877_i_F_100902 => N_100000__I_100877_i_F_100938 - N_100000__I_100877_i_F_100905 => N_100000__I_100877_i_F_100920 - !(N_100000__I_100877_i_F_100914 & N_100000__I_100877_i_F_100956) - !(N_100000__I_100877_i_F_100914 & N_100000__I_100877_i_F_100959) - N_100000__I_100877_i_F_100914 => N_100000__I_100877_i_F_100965 - !(N_100000__I_100877_i_F_100914 & N_104687__F_104698) - N_100000__I_100976_i_F_100980 => N_100000__I_100976_i_F_101019 - N_100000__I_100976_i_F_100983 => N_100000__I_100976_i_F_101037 - N_100000__I_100976_i_F_100986 => N_100000__I_100976_i_F_101037 - N_100000__I_100976_i_F_100989 => N_100000__I_100976_i_F_101034 - !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101019) - !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101022) - !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101025) - !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101034) - !(N_100000__I_100976_i_F_100992 & N_100000__I_100976_i_F_101037) - !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101019) - !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101022) - !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101025) - !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101034) - !(N_100000__I_100976_i_F_100995 & N_100000__I_100976_i_F_101037) - N_100000__I_100976_i_F_100998 => N_100000__I_100976_i_F_101025 - N_100000__I_100976_i_F_101001 => N_100000__I_100976_i_F_101037 - N_100000__I_100976_i_F_101004 => N_100000__I_100976_i_F_101019 - !(N_100000__I_100976_i_F_101013 & N_100000__I_100976_i_F_101055) - !(N_100000__I_100976_i_F_101013 & N_100000__I_100976_i_F_101058) - N_100000__I_100976_i_F_101013 => N_100000__I_100976_i_F_101064 - !(N_100000__I_100976_i_F_101013 & N_104687__F_104698) - N_100000__I_101075_i_F_101079 => N_100000__I_101075_i_F_101118 - N_100000__I_101075_i_F_101082 => N_100000__I_101075_i_F_101136 - N_100000__I_101075_i_F_101085 => N_100000__I_101075_i_F_101136 - N_100000__I_101075_i_F_101088 => N_100000__I_101075_i_F_101133 - !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101118) - !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101121) - !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101124) - !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101133) - !(N_100000__I_101075_i_F_101091 & N_100000__I_101075_i_F_101136) - !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101118) - !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101121) - !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101124) - !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101133) - !(N_100000__I_101075_i_F_101094 & N_100000__I_101075_i_F_101136) - N_100000__I_101075_i_F_101097 => N_100000__I_101075_i_F_101124 - N_100000__I_101075_i_F_101100 => N_100000__I_101075_i_F_101136 - N_100000__I_101075_i_F_101103 => N_100000__I_101075_i_F_101118 - !(N_100000__I_101075_i_F_101112 & N_100000__I_101075_i_F_101154) - !(N_100000__I_101075_i_F_101112 & N_100000__I_101075_i_F_101157) - N_100000__I_101075_i_F_101112 => N_100000__I_101075_i_F_101163 - !(N_100000__I_101075_i_F_101112 & N_104687__F_104698) - N_100000__I_101174_i_F_101178 => N_100000__I_101174_i_F_101217 - N_100000__I_101174_i_F_101181 => N_100000__I_101174_i_F_101235 - N_100000__I_101174_i_F_101184 => N_100000__I_101174_i_F_101235 - N_100000__I_101174_i_F_101187 => N_100000__I_101174_i_F_101232 - !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101217) - !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101220) - !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101223) - !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101232) - !(N_100000__I_101174_i_F_101190 & N_100000__I_101174_i_F_101235) - !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101217) - !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101220) - !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101223) - !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101232) - !(N_100000__I_101174_i_F_101193 & N_100000__I_101174_i_F_101235) - N_100000__I_101174_i_F_101196 => N_100000__I_101174_i_F_101223 - N_100000__I_101174_i_F_101199 => N_100000__I_101174_i_F_101235 - N_100000__I_101174_i_F_101202 => N_100000__I_101174_i_F_101217 - !(N_100000__I_101174_i_F_101211 & N_100000__I_101174_i_F_101253) - !(N_100000__I_101174_i_F_101211 & N_100000__I_101174_i_F_101256) - N_100000__I_101174_i_F_101211 => N_100000__I_101174_i_F_101262 - !(N_100000__I_101174_i_F_101211 & N_104687__F_104698) - N_100000__I_101285_i_F_101289 => N_100000__I_101285_i_F_101298 - N_100000__I_101285_i_F_101289 => N_100000__I_101285_i_F_101304 - N_100000__I_101285_i_F_101292 => N_100000__I_101285_i_F_101298 - N_100000__I_101285_i_F_101292 => N_100000__I_101285_i_F_101307 - N_100000__I_101285_i_F_101298 => N_100000__I_101285_i_F_101313 - N_100000__I_101405_i_F_101409 => N_100000__I_101405_i_F_101418 - N_100000__I_101405_i_F_101409 => N_100000__I_101405_i_F_101424 - N_100000__I_101405_i_F_101412 => N_100000__I_101405_i_F_101418 - N_100000__I_101405_i_F_101412 => N_100000__I_101405_i_F_101427 - N_100000__I_101405_i_F_101418 => N_100000__I_101405_i_F_101433 - N_100000__I_101525_i_F_101529 => N_100000__I_101525_i_F_101538 - N_100000__I_101525_i_F_101529 => N_100000__I_101525_i_F_101544 - N_100000__I_101525_i_F_101532 => N_100000__I_101525_i_F_101538 - N_100000__I_101525_i_F_101532 => N_100000__I_101525_i_F_101547 - N_100000__I_101525_i_F_101538 => N_100000__I_101525_i_F_101553 - N_100000__I_101645_i_F_101649 => N_100000__I_101645_i_F_101658 - N_100000__I_101645_i_F_101649 => N_100000__I_101645_i_F_101664 - N_100000__I_101645_i_F_101652 => N_100000__I_101645_i_F_101658 - N_100000__I_101645_i_F_101652 => N_100000__I_101645_i_F_101667 - N_100000__I_101645_i_F_101658 => N_100000__I_101645_i_F_101673 - N_101932__F_101949 => N_101932__F_101988 - N_101932__F_101949 => N_101932__F_101989 - N_101932__F_101950 => N_101932__F_101988 - N_101932__F_101950 => N_101932__F_101989 - N_101932__F_101951 => N_101932__F_101988 - N_101932__F_101951 => N_101932__F_101989 - !(N_102004__F_102012 & "N_102004__F_102013") - N_102004__F_102020 => "N_104357__F_104386" - !("N_104284__F_104297" & "N_104284__F_104311") - !(N_104357__F_104411 & N_104357__F_104400) - !(N_104357__F_104411 & "N_104357__F_104401") - !(N_104357__F_104411 & "N_104357__F_104521") - N_104357__F_104411 => N_104357__F_104457 - N_104357__F_104411 => N_104357__F_104461 - N_104357__F_104411 => N_104357__F_104472 - N_104357__F_104411 => N_104357__F_104478 - N_104357__F_104411 => N_104357__F_104517 - N_104357__F_104411 => N_104357__F_104520 - N_104357__F_104411 => N_104357__F_104484 - N_104357__F_104411 => N_104357__F_104488 - N_104357__F_104411 => N_104357__F_104490 - !(N_104357__F_104411 & "N_104357__F_104497") - !(N_104357__F_104412 & N_104357__F_104400) - !(N_104357__F_104412 & "N_104357__F_104401") - !(N_104357__F_104412 & "N_104357__F_104521") - !(N_104357__F_104412 & N_104357__F_104480) - N_104357__F_104412 => N_104357__F_104457 - N_104357__F_104412 => N_104357__F_104461 - N_104357__F_104412 => N_104357__F_104473 - N_104357__F_104412 => "N_104357__F_104479" - N_104357__F_104412 => N_104357__F_104484 - N_104357__F_104412 => N_104357__F_104488 - N_104357__F_104412 => N_104357__F_104490 - N_104357__F_104412 => N_104357__F_104517 - N_104357__F_104412 => N_104357__F_104519 - !(N_104357__F_104412 & "N_104357__F_104497") - !(N_104357__F_104413 & N_104357__F_104400) - !(N_104357__F_104413 & "N_104357__F_104401") - !(N_104357__F_104413 & "N_104357__F_104521") - !(N_104357__F_104413 & N_104357__F_104480) - N_104357__F_104413 => N_104357__F_104457 - N_104357__F_104413 => N_104357__F_104461 - N_104357__F_104413 => N_104357__F_104474 - N_104357__F_104413 => "N_104357__F_104479" - N_104357__F_104413 => N_104357__F_104484 - N_104357__F_104413 => N_104357__F_104488 - N_104357__F_104413 => N_104357__F_104491 - N_104357__F_104413 => N_104357__F_104517 - N_104357__F_104413 => N_104357__F_104519 - !(N_104357__F_104413 & "N_104357__F_104497") - !(N_104357__F_104414 & "N_104357__F_104401") - !(N_104357__F_104414 & "N_104357__F_104521") - !(N_104357__F_104414 & N_104357__F_104480) - N_104357__F_104414 => N_104357__F_104458 - N_104357__F_104414 => N_104357__F_104462 - N_104357__F_104414 => N_104357__F_104473 - N_104357__F_104414 => "N_104357__F_104479" - N_104357__F_104414 => N_104357__F_104485 - N_104357__F_104414 => N_104357__F_104487 - N_104357__F_104414 => N_104357__F_104490 - N_104357__F_104414 => N_104357__F_104516 - N_104357__F_104414 => N_104357__F_104519 - !(N_104357__F_104414 & "N_104357__F_104497") - !(N_104357__F_104415 & N_104357__F_104480) - !(N_104357__F_104415 & "N_104357__F_104401") - !(N_104357__F_104415 & "N_104357__F_104521") - N_104357__F_104415 => N_104357__F_104458 - N_104357__F_104415 => N_104357__F_104462 - N_104357__F_104415 => N_104357__F_104474 - N_104357__F_104415 => "N_104357__F_104479" - N_104357__F_104415 => N_104357__F_104485 - N_104357__F_104415 => N_104357__F_104487 - N_104357__F_104415 => N_104357__F_104491 - N_104357__F_104415 => N_104357__F_104516 - N_104357__F_104415 => N_104357__F_104519 - !(N_104357__F_104415 & "N_104357__F_104497") - !(N_104357__F_104416 & N_104357__F_104480) - !(N_104357__F_104416 & "N_104357__F_104401") - !(N_104357__F_104416 & "N_104357__F_104521") - N_104357__F_104416 => N_104357__F_104458 - N_104357__F_104416 => N_104357__F_104461 - N_104357__F_104416 => N_104357__F_104473 - N_104357__F_104416 => "N_104357__F_104479" - N_104357__F_104416 => N_104357__F_104484 - N_104357__F_104416 => N_104357__F_104487 - N_104357__F_104416 => N_104357__F_104490 - N_104357__F_104416 => N_104357__F_104516 - N_104357__F_104416 => N_104357__F_104519 - !(N_104357__F_104416 & "N_104357__F_104497") - !(N_104357__F_104417 & N_104357__F_104480) - !(N_104357__F_104417 & "N_104357__F_104401") - !(N_104357__F_104417 & "N_104357__F_104521") - N_104357__F_104417 => N_104357__F_104458 - N_104357__F_104417 => N_104357__F_104461 - N_104357__F_104417 => N_104357__F_104474 - N_104357__F_104417 => "N_104357__F_104479" - N_104357__F_104417 => N_104357__F_104484 - N_104357__F_104417 => N_104357__F_104487 - N_104357__F_104417 => N_104357__F_104491 - N_104357__F_104417 => N_104357__F_104516 - N_104357__F_104417 => N_104357__F_104519 - !(N_104357__F_104417 & "N_104357__F_104497") - !(N_104357__F_104418 & "N_104357__F_104521") - N_104357__F_104418 => N_104357__F_104458 - N_104357__F_104418 => N_104357__F_104462 - N_104357__F_104418 => "N_104357__F_104479" - N_104357__F_104418 => N_104357__F_104480 - N_104357__F_104418 => N_104357__F_104485 - N_104357__F_104418 => N_104357__F_104487 - N_104357__F_104418 => N_104357__F_104516 - N_104357__F_104418 => N_104357__F_104519 - N_104357__F_104418 => "N_104357__F_104401" - N_104357__F_104418 => N_104357__F_104490 - N_104357__F_104418 => N_104357__F_104473 - N_104357__F_104418 => N_104357__F_104498 - !(N_104357__F_104419 & "N_104357__F_104521") - N_104357__F_104419 => N_104357__F_104458 - N_104357__F_104419 => N_104357__F_104462 - N_104357__F_104419 => N_104357__F_104481 - N_104357__F_104419 => N_104357__F_104485 - N_104357__F_104419 => N_104357__F_104487 - N_104357__F_104419 => "N_104357__F_104401" - N_104357__F_104419 => N_104357__F_104516 - N_104357__F_104419 => N_104357__F_104519 - N_104357__F_104419 => N_104357__F_104475 - N_104357__F_104419 => N_104357__F_104490 - N_104357__F_104419 => N_104357__F_104498 - !(N_104357__F_104420 & "N_104357__F_104521") - N_104357__F_104420 => N_104357__F_104458 - N_104357__F_104420 => N_104357__F_104462 - N_104357__F_104420 => N_104357__F_104481 - N_104357__F_104420 => N_104357__F_104519 - N_104357__F_104420 => N_104357__F_104516 - N_104357__F_104420 => N_104357__F_104490 - N_104357__F_104420 => N_104357__F_104487 - N_104357__F_104420 => N_104357__F_104485 - N_104357__F_104420 => "N_104357__F_104401" - N_104357__F_104420 => N_104357__F_104475 - N_104357__F_104420 => N_104357__F_104499 - !(N_104357__F_104421 & N_104357__F_104480) - !(N_104357__F_104421 & "N_104357__F_104401") - N_104357__F_104421 => N_104357__F_104458 - N_104357__F_104421 => N_104357__F_104462 - N_104357__F_104421 => N_104357__F_104473 - N_104357__F_104421 => "N_104357__F_104479" - N_104357__F_104421 => N_104357__F_104485 - N_104357__F_104421 => N_104357__F_104487 - N_104357__F_104421 => N_104357__F_104490 - N_104357__F_104421 => N_104357__F_104516 - N_104357__F_104421 => N_104357__F_104519 - N_104357__F_104421 => "N_104357__F_104521" - !(N_104357__F_104421 & "N_104357__F_104497") - !(N_104357__F_104422 & N_104357__F_104480) - !(N_104357__F_104422 & "N_104357__F_104401") - N_104357__F_104422 => N_104357__F_104458 - N_104357__F_104422 => N_104357__F_104462 - N_104357__F_104422 => N_104357__F_104474 - N_104357__F_104422 => "N_104357__F_104479" - N_104357__F_104422 => N_104357__F_104485 - N_104357__F_104422 => N_104357__F_104487 - N_104357__F_104422 => N_104357__F_104491 - N_104357__F_104422 => N_104357__F_104516 - N_104357__F_104422 => N_104357__F_104519 - N_104357__F_104422 => "N_104357__F_104521" - !(N_104357__F_104422 & "N_104357__F_104497") - !(N_104357__F_104423 & N_104357__F_104480) - !(N_104357__F_104423 & "N_104357__F_104401") - N_104357__F_104423 => N_104357__F_104458 - N_104357__F_104423 => N_104357__F_104462 - N_104357__F_104423 => N_104357__F_104474 - N_104357__F_104423 => "N_104357__F_104479" - N_104357__F_104423 => N_104357__F_104485 - N_104357__F_104423 => N_104357__F_104487 - N_104357__F_104423 => N_104357__F_104491 - N_104357__F_104423 => N_104357__F_104516 - N_104357__F_104423 => N_104357__F_104519 - N_104357__F_104423 => "N_104357__F_104521" - !(N_104357__F_104423 & "N_104357__F_104497") - N_104357__F_104424 => N_104357__F_104458 - N_104357__F_104424 => N_104357__F_104462 - N_104357__F_104424 => "N_104357__F_104479" - N_104357__F_104424 => N_104357__F_104480 - N_104357__F_104424 => N_104357__F_104485 - N_104357__F_104424 => N_104357__F_104487 - N_104357__F_104424 => N_104357__F_104490 - N_104357__F_104424 => "N_104357__F_104401" - N_104357__F_104424 => N_104357__F_104516 - N_104357__F_104424 => N_104357__F_104519 - N_104357__F_104424 => "N_104357__F_104521" - N_104357__F_104424 => N_104357__F_104473 - N_104357__F_104424 => N_104357__F_104498 - N_104357__F_104425 => N_104357__F_104458 - N_104357__F_104425 => N_104357__F_104462 - N_104357__F_104425 => N_104357__F_104481 - N_104357__F_104425 => N_104357__F_104485 - N_104357__F_104425 => N_104357__F_104487 - N_104357__F_104425 => "N_104357__F_104401" - N_104357__F_104425 => N_104357__F_104516 - N_104357__F_104425 => N_104357__F_104519 - N_104357__F_104425 => "N_104357__F_104521" - N_104357__F_104425 => N_104357__F_104490 - N_104357__F_104425 => N_104357__F_104475 - N_104357__F_104425 => N_104357__F_104498 - N_104357__F_104426 => N_104357__F_104458 - N_104357__F_104426 => N_104357__F_104462 - N_104357__F_104426 => N_104357__F_104481 - N_104357__F_104426 => N_104357__F_104485 - N_104357__F_104426 => N_104357__F_104487 - N_104357__F_104426 => "N_104357__F_104401" - N_104357__F_104426 => N_104357__F_104516 - N_104357__F_104426 => N_104357__F_104519 - N_104357__F_104426 => "N_104357__F_104521" - N_104357__F_104426 => N_104357__F_104490 - N_104357__F_104426 => N_104357__F_104475 - N_104357__F_104426 => N_104357__F_104499 - N_104357__F_104428 => N_104357__F_104464 - !(N_104357__F_104428 & "N_104357__F_104467") - N_104357__F_104429 => N_104357__F_104465 - !(N_104357__F_104429 & "N_104357__F_104467") - N_104357__F_104430 => N_104357__F_104464 - N_104357__F_104430 => N_104357__F_104469 - N_104357__F_104431 => N_104357__F_104469 - N_104357__F_104431 => N_104357__F_104465 - !(N_104357__F_104432 & "N_104357__F_104467") - N_104357__F_104432 => N_104357__F_104466 - N_104357__F_104434 => N_104357__F_104500 - N_104357__F_104434 => N_104357__F_104495 - !(N_104357__F_104434 & "N_104357__F_104521") - !(N_104357__F_104434 & N_104357__F_104403) - !(N_104357__F_104434 & N_104357__F_104406) - !(N_104357__F_104434 & N_104357__F_104407) - N_104357__F_104435 => N_104357__F_104494 - N_104357__F_104435 => N_104357__F_104500 - !(N_104357__F_104435 & "N_104357__F_104521") - !(N_104357__F_104435 & N_104357__F_104403) - !(N_104357__F_104435 & N_104357__F_104407) - N_104357__F_104436 => N_104357__F_104494 - N_104357__F_104436 => N_104357__F_104500 - N_104357__F_104436 => "N_104357__F_104521" - !(N_104357__F_104436 & N_104357__F_104522) - !(N_104357__F_104436 & N_104357__F_104403) - !(N_104357__F_104436 & N_104357__F_104407) - N_104357__F_104437 => N_104357__F_104494 - N_104357__F_104437 => N_104357__F_104500 - N_104357__F_104437 => "N_104357__F_104521" - N_104357__F_104437 => N_104357__F_104522 - !(N_104357__F_104437 & N_104357__F_104403) - !(N_104357__F_104437 & N_104357__F_104407) - N_104357__F_104438 => N_104357__F_104494 - N_104357__F_104438 => "N_104357__F_104501" - !(N_104357__F_104438 & "N_104357__F_104521") - N_104357__F_104439 => N_104357__F_104494 - N_104357__F_104439 => "N_104357__F_104501" - N_104357__F_104439 => "N_104357__F_104521" - !(N_104357__F_104439 & N_104357__F_104522) - N_104357__F_104440 => N_104357__F_104494 - N_104357__F_104440 => "N_104357__F_104501" - N_104357__F_104440 => "N_104357__F_104521" - N_104357__F_104440 => N_104357__F_104522 - !(N_104357__F_104442 & "N_104357__F_104504") - !(N_104357__F_104442 & N_104357__F_104502) - !(N_104357__F_104442 & N_104357__F_104407) - N_104357__F_104443 => "N_104357__F_104504" - !(N_104357__F_104443 & N_104357__F_104502) - N_104357__F_104444 => N_104357__F_104502 - !(N_104357__F_104444 & "N_104357__F_104504") - !(N_104357__F_104445 & N_104357__F_104502) - N_104357__F_104445 => N_104357__F_104405 - N_104357__F_104445 => N_104357__F_104505 - !(N_104357__F_104447 & N_104357__F_104523) - N_104357__F_104448 => N_104357__F_104523 - N_104357__F_104449 => N_104357__F_104523 - !(N_104357__F_104451 & "N_104357__F_104506") - N_104357__F_104452 => N_104357__F_104507 - N_104357__F_104453 => N_104357__F_104508 - N_104357__F_104454 => N_104357__F_104405 - N_104357__F_104454 => N_104357__F_104509 - N_104357__F_104457 => N_104357__F_104488 - N_104357__F_104458 => N_104357__F_104487 - N_104357__F_104522 => N_104357__F_104502 - "N_104536__I_104581_i_F_104582" => N_104536__I_104581_i_F_104585 - !("N_104536__I_104581_i_F_104582" & N_104536__I_104581_i_F_104588) - "N_104536__I_104626_i_F_104627" => N_104536__I_104626_i_F_104630 - !("N_104536__I_104626_i_F_104627" & N_104536__I_104626_i_F_104633) - N_104700__F_104703 => N_104357__F_104511 - N_104700__F_104704 => N_104357__F_104511 - N_104700__F_104705 => N_104357__F_104512 - N_104700__F_104709 => N_104357__F_104512 - N_104700__F_104710 => N_104357__F_104511 - N_104700__F_104711 => N_104357__F_104511 - N_104700__F_104713 => N_104357__F_104513 - N_104700__F_104714 => N_104357__F_104513 - N_104700__F_104715 => N_104357__F_104513 - N_104700__F_104716 => N_104357__F_104511 - N_104700__F_104717 => N_104357__F_104511 - N_104700__F_104723 => N_104357__F_104511 - N_104700__F_104726 => N_104357__F_104511 - N_100000__I_100877_i_F_100920 => N_100000__I_100877_i_F_100971 - !(N_100000__I_100877_i_F_100920 & N_100000__I_100877_i_F_100956) - !(N_100000__I_100877_i_F_100920 & N_100000__I_100877_i_F_100959) - N_100000__I_100877_i_F_100923 => N_100000__I_100877_i_F_100968 - !(N_100000__I_100877_i_F_100923 & N_100000__I_100877_i_F_100956) - !(N_100000__I_100877_i_F_100923 & N_100000__I_100877_i_F_100959) - N_100000__I_100877_i_F_100926 => N_100000__I_100877_i_F_100968 - N_100000__I_100877_i_F_100926 => N_100000__I_100877_i_F_100956 - N_100000__I_100877_i_F_100926 => N_100000__I_100877_i_F_100959 - N_100000__I_100877_i_F_100929 => N_100000__I_100877_i_F_100965 - !(N_100000__I_100877_i_F_100929 & N_100000__I_100877_i_F_100956) - !(N_100000__I_100877_i_F_100929 & N_100000__I_100877_i_F_100959) - N_100000__I_100877_i_F_100932 => N_100000__I_100877_i_F_100965 - !(N_100000__I_100877_i_F_100932 & N_100000__I_100877_i_F_100956) - !(N_100000__I_100877_i_F_100932 & N_100000__I_100877_i_F_100959) - N_100000__I_100877_i_F_100935 => N_100000__I_100877_i_F_100965 - N_100000__I_100877_i_F_100935 => N_100000__I_100877_i_F_100956 - !(N_100000__I_100877_i_F_100935 & N_100000__I_100877_i_F_100959) - N_100000__I_100877_i_F_100938 => N_100000__I_100877_i_F_100971 - N_100000__I_100877_i_F_100938 => N_100000__I_100877_i_F_100956 - N_100000__I_100877_i_F_100938 => N_100000__I_100877_i_F_100959 - N_100000__I_100877_i_F_100941 => N_100000__I_100877_i_F_100965 - !(N_100000__I_100877_i_F_100941 & N_100000__I_100877_i_F_100956) - !(N_100000__I_100877_i_F_100941 & N_100000__I_100877_i_F_100959) - N_100000__I_100976_i_F_101019 => N_100000__I_100976_i_F_101070 - !(N_100000__I_100976_i_F_101019 & N_100000__I_100976_i_F_101055) - !(N_100000__I_100976_i_F_101019 & N_100000__I_100976_i_F_101058) - N_100000__I_100976_i_F_101022 => N_100000__I_100976_i_F_101067 - !(N_100000__I_100976_i_F_101022 & N_100000__I_100976_i_F_101055) - !(N_100000__I_100976_i_F_101022 & N_100000__I_100976_i_F_101058) - N_100000__I_100976_i_F_101025 => N_100000__I_100976_i_F_101067 - N_100000__I_100976_i_F_101025 => N_100000__I_100976_i_F_101055 - N_100000__I_100976_i_F_101025 => N_100000__I_100976_i_F_101058 - N_100000__I_100976_i_F_101028 => N_100000__I_100976_i_F_101064 - !(N_100000__I_100976_i_F_101028 & N_100000__I_100976_i_F_101055) - !(N_100000__I_100976_i_F_101028 & N_100000__I_100976_i_F_101058) - N_100000__I_100976_i_F_101031 => N_100000__I_100976_i_F_101064 - !(N_100000__I_100976_i_F_101031 & N_100000__I_100976_i_F_101055) - !(N_100000__I_100976_i_F_101031 & N_100000__I_100976_i_F_101058) - N_100000__I_100976_i_F_101034 => N_100000__I_100976_i_F_101064 - N_100000__I_100976_i_F_101034 => N_100000__I_100976_i_F_101055 - !(N_100000__I_100976_i_F_101034 & N_100000__I_100976_i_F_101058) - N_100000__I_100976_i_F_101037 => N_100000__I_100976_i_F_101070 - N_100000__I_100976_i_F_101037 => N_100000__I_100976_i_F_101055 - N_100000__I_100976_i_F_101037 => N_100000__I_100976_i_F_101058 - N_100000__I_100976_i_F_101040 => N_100000__I_100976_i_F_101064 - !(N_100000__I_100976_i_F_101040 & N_100000__I_100976_i_F_101055) - !(N_100000__I_100976_i_F_101040 & N_100000__I_100976_i_F_101058) - N_100000__I_101075_i_F_101118 => N_100000__I_101075_i_F_101169 - !(N_100000__I_101075_i_F_101118 & N_100000__I_101075_i_F_101154) - !(N_100000__I_101075_i_F_101118 & N_100000__I_101075_i_F_101157) - N_100000__I_101075_i_F_101121 => N_100000__I_101075_i_F_101166 - !(N_100000__I_101075_i_F_101121 & N_100000__I_101075_i_F_101154) - !(N_100000__I_101075_i_F_101121 & N_100000__I_101075_i_F_101157) - N_100000__I_101075_i_F_101124 => N_100000__I_101075_i_F_101166 - N_100000__I_101075_i_F_101124 => N_100000__I_101075_i_F_101154 - N_100000__I_101075_i_F_101124 => N_100000__I_101075_i_F_101157 - N_100000__I_101075_i_F_101127 => N_100000__I_101075_i_F_101163 - !(N_100000__I_101075_i_F_101127 & N_100000__I_101075_i_F_101154) - !(N_100000__I_101075_i_F_101127 & N_100000__I_101075_i_F_101157) - N_100000__I_101075_i_F_101130 => N_100000__I_101075_i_F_101163 - !(N_100000__I_101075_i_F_101130 & N_100000__I_101075_i_F_101154) - !(N_100000__I_101075_i_F_101130 & N_100000__I_101075_i_F_101157) - N_100000__I_101075_i_F_101133 => N_100000__I_101075_i_F_101163 - N_100000__I_101075_i_F_101133 => N_100000__I_101075_i_F_101154 - !(N_100000__I_101075_i_F_101133 & N_100000__I_101075_i_F_101157) - N_100000__I_101075_i_F_101136 => N_100000__I_101075_i_F_101169 - N_100000__I_101075_i_F_101136 => N_100000__I_101075_i_F_101154 - N_100000__I_101075_i_F_101136 => N_100000__I_101075_i_F_101157 - N_100000__I_101075_i_F_101139 => N_100000__I_101075_i_F_101163 - !(N_100000__I_101075_i_F_101139 & N_100000__I_101075_i_F_101154) - !(N_100000__I_101075_i_F_101139 & N_100000__I_101075_i_F_101157) - N_100000__I_101174_i_F_101217 => N_100000__I_101174_i_F_101268 - !(N_100000__I_101174_i_F_101217 & N_100000__I_101174_i_F_101253) - !(N_100000__I_101174_i_F_101217 & N_100000__I_101174_i_F_101256) - N_100000__I_101174_i_F_101220 => N_100000__I_101174_i_F_101265 - !(N_100000__I_101174_i_F_101220 & N_100000__I_101174_i_F_101253) - !(N_100000__I_101174_i_F_101220 & N_100000__I_101174_i_F_101256) - N_100000__I_101174_i_F_101223 => N_100000__I_101174_i_F_101265 - N_100000__I_101174_i_F_101223 => N_100000__I_101174_i_F_101253 - N_100000__I_101174_i_F_101223 => N_100000__I_101174_i_F_101256 - N_100000__I_101174_i_F_101226 => N_100000__I_101174_i_F_101262 - !(N_100000__I_101174_i_F_101226 & N_100000__I_101174_i_F_101253) - !(N_100000__I_101174_i_F_101226 & N_100000__I_101174_i_F_101256) - N_100000__I_101174_i_F_101229 => N_100000__I_101174_i_F_101262 - !(N_100000__I_101174_i_F_101229 & N_100000__I_101174_i_F_101253) - !(N_100000__I_101174_i_F_101229 & N_100000__I_101174_i_F_101256) - N_100000__I_101174_i_F_101232 => N_100000__I_101174_i_F_101262 - N_100000__I_101174_i_F_101232 => N_100000__I_101174_i_F_101253 - !(N_100000__I_101174_i_F_101232 & N_100000__I_101174_i_F_101256) - N_100000__I_101174_i_F_101235 => N_100000__I_101174_i_F_101268 - N_100000__I_101174_i_F_101235 => N_100000__I_101174_i_F_101253 - N_100000__I_101174_i_F_101235 => N_100000__I_101174_i_F_101256 - N_100000__I_101174_i_F_101238 => N_100000__I_101174_i_F_101262 - !(N_100000__I_101174_i_F_101238 & N_100000__I_101174_i_F_101253) - !(N_100000__I_101174_i_F_101238 & N_100000__I_101174_i_F_101256) - N_100000__I_101285_i_F_101322 => "N_100000__I_101285_i_F_101334" - N_100000__I_101285_i_F_101325 => "N_100000__I_101285_i_F_101343" - N_100000__I_101285_i_F_101328 => "N_100000__I_101285_i_F_101343" - N_100000__I_101285_i_F_101331 => N_100000__I_101285_i_F_101358 - N_100000__I_101285_i_F_101358 => N_100000__I_101285_i_F_101385 - N_100000__I_101405_i_F_101442 => "N_100000__I_101405_i_F_101454" - N_100000__I_101405_i_F_101445 => "N_100000__I_101405_i_F_101463" - N_100000__I_101405_i_F_101448 => "N_100000__I_101405_i_F_101463" - N_100000__I_101405_i_F_101451 => N_100000__I_101405_i_F_101478 - N_100000__I_101405_i_F_101478 => N_100000__I_101405_i_F_101505 - N_100000__I_101525_i_F_101562 => "N_100000__I_101525_i_F_101574" - N_100000__I_101525_i_F_101565 => "N_100000__I_101525_i_F_101583" - N_100000__I_101525_i_F_101568 => "N_100000__I_101525_i_F_101583" - N_100000__I_101525_i_F_101571 => N_100000__I_101525_i_F_101598 - N_100000__I_101525_i_F_101598 => N_100000__I_101525_i_F_101625 - N_100000__I_101645_i_F_101682 => "N_100000__I_101645_i_F_101694" - N_100000__I_101645_i_F_101685 => "N_100000__I_101645_i_F_101703" - N_100000__I_101645_i_F_101688 => "N_100000__I_101645_i_F_101703" - N_100000__I_101645_i_F_101691 => N_100000__I_101645_i_F_101718 - N_100000__I_101645_i_F_101718 => N_100000__I_101645_i_F_101745 - !(N_102385__F_102488 & N_102385__F_102457) - !(N_102385__F_102488 & N_102385__F_102458) - !(N_102385__F_102488 & N_102385__F_102459) - N_102383__F_102779 => N_102383__F_102782 - N_102383__F_102779 => N_102383__F_102783 - N_102383__F_102779 => N_102383__F_102784 - N_102383__F_102779 => N_102383__F_102785 - N_102383__F_102779 => N_102383__F_102786 - N_102383__F_102779 => N_102383__F_102787 - N_102383__F_102790 => N_102383__I_103300_i_F_103304 - N_102383__F_102790 => N_102383__I_103546_i_F_103550 - N_102383__F_102790 => N_102383__I_103792_i_F_103796 - N_102383__F_102790 => N_102383__I_104038_i_F_104042 - N_102383__F_102790 => N_102383__I_102808_i_F_103010 - N_102383__F_102790 => N_102383__I_103054_i_F_103256 - N_102383__F_102790 => N_104687__F_104692 - N_102383__F_102790 => N_104687__F_104695 - N_102383__F_102791 => N_102383__I_103300_i_F_103307 - N_102383__F_102791 => N_102383__I_103546_i_F_103553 - N_102383__F_102791 => N_102383__I_103792_i_F_103799 - N_102383__F_102791 => N_102383__I_104038_i_F_104045 - N_102383__F_102791 => N_102383__I_102808_i_F_103016 - N_102383__F_102791 => N_102383__I_103054_i_F_103262 - N_102383__F_102792 => N_102383__I_103300_i_F_103310 - N_102383__F_102792 => N_102383__I_103546_i_F_103556 - N_102383__F_102792 => N_102383__I_103792_i_F_103802 - N_102383__F_102792 => N_102383__I_104038_i_F_104048 - N_102383__F_102792 => N_102383__I_102808_i_F_103019 - N_102383__F_102792 => N_102383__I_103054_i_F_103265 - N_102383__F_102793 => N_102383__I_102808_i_F_103022 - N_102383__F_102793 => N_102383__I_103054_i_F_103268 - N_102383__F_102793 => N_102383__I_103300_i_F_103316 - N_102383__F_102793 => N_102383__I_103546_i_F_103562 - N_102383__F_102793 => N_102383__I_104038_i_F_104054 - N_102383__F_102793 => N_102383__I_103792_i_F_103808 - N_102383__F_102794 => N_102383__I_102808_i_F_103025 - N_102383__F_102794 => N_102383__I_103054_i_F_103271 - N_102383__F_102794 => N_102383__I_103300_i_F_103319 - N_102383__F_102794 => N_102383__I_103546_i_F_103565 - N_102383__F_102794 => N_102383__I_104038_i_F_104057 - N_102383__F_102794 => N_102383__I_103792_i_F_103811 - N_102383__F_102796 => N_102383__I_102808_i_F_103028 - N_102383__F_102796 => N_102383__I_103054_i_F_103274 - N_102383__F_102796 => N_102383__I_103300_i_F_103322 - N_102383__F_102796 => N_102383__I_103546_i_F_103568 - N_102383__F_102796 => N_102383__I_103792_i_F_103814 - N_102383__F_102796 => N_102383__I_104038_i_F_104060 - N_102383__F_102797 => N_102383__I_103300_i_F_103325 - N_102383__F_102797 => N_102383__I_103546_i_F_103571 - N_102383__F_102797 => N_102383__I_103792_i_F_103817 - N_102383__F_102797 => N_102383__I_104038_i_F_104063 - N_102383__F_102798 => N_102383__I_102808_i_F_103013 - N_102383__F_102798 => N_102383__I_103054_i_F_103259 - N_102383__F_102798 => N_102383__I_103300_i_F_103304 - N_102383__F_102798 => N_102383__I_103546_i_F_103550 - N_102383__F_102798 => N_102383__I_103792_i_F_103796 - N_102383__F_102798 => N_102383__I_104038_i_F_104042 - N_102383__F_102798 => N_104687__F_104693 - N_102383__F_102798 => N_104687__F_104696 - N_102383__F_102799 => N_102383__I_102808_i_F_103031 - N_102383__F_102799 => N_102383__I_103054_i_F_103277 - N_102383__F_102799 => N_102383__I_103300_i_F_103313 - N_102383__F_102799 => N_102383__I_103546_i_F_103559 - N_102383__F_102799 => N_102383__I_103792_i_F_103805 - N_102383__F_102799 => N_102383__I_104038_i_F_104051 - N_102383__F_102800 => N_102383__I_103300_i_F_103331 - N_102383__F_102800 => N_102383__I_103546_i_F_103577 - N_102383__F_102800 => N_102383__I_103792_i_F_103823 - N_102383__F_102800 => N_102383__I_104038_i_F_104069 - N_102383__F_102800 => N_104687__F_104699 - N_102383__F_102801 => N_102383__I_103300_i_F_103328 - N_102383__F_102801 => N_102383__I_103546_i_F_103574 - N_102383__F_102801 => N_102383__I_103792_i_F_103820 - N_102383__F_102801 => N_102383__I_104038_i_F_104066 - N_102383__F_102801 => "N_104687__F_104694" - N_102383__F_102801 => "N_104687__F_104691" - N_102383__F_102802 => N_102383__I_103300_i_F_103334 - N_102383__F_102802 => N_102383__I_103546_i_F_103580 - N_102383__F_102802 => N_102383__I_103792_i_F_103826 - N_102383__F_102802 => N_102383__I_104038_i_F_104072 - N_102383__F_102802 => N_104687__F_104692 - N_102383__F_102802 => N_104687__F_104695 - N_102383__F_102803 => N_102383__I_103300_i_F_103337 - N_102383__F_102803 => N_102383__I_103546_i_F_103583 - N_102383__F_102803 => N_102383__I_103792_i_F_103829 - N_102383__F_102803 => N_102383__I_104038_i_F_104075 - N_102383__F_102803 => N_104687__F_104692 - N_102383__F_102803 => N_104687__F_104695 - N_102383__F_102804 => N_102383__I_103300_i_F_103340 - N_102383__F_102804 => N_102383__I_103546_i_F_103586 - N_102383__F_102804 => N_102383__I_103792_i_F_103832 - N_102383__F_102804 => N_102383__I_104038_i_F_104078 - N_102383__F_102804 => N_104687__F_104692 - N_102383__F_102804 => N_104687__F_104695 - N_102383__F_102805 => N_102383__I_103300_i_F_103343 - N_102383__F_102805 => N_102383__I_103546_i_F_103589 - N_102383__F_102805 => N_102383__I_103792_i_F_103835 - N_102383__F_102805 => N_102383__I_104038_i_F_104081 - N_102383__F_102805 => N_100000__F_101275 - N_102383__F_102805 => N_100000__F_101276 - !("N_104284__F_104291" & "N_104284__F_104297") - !(N_104284__F_104309 & N_104284__F_104332) - N_104284__F_104310 => N_104284__F_104332 - !(N_104284__F_104327 & N_104284__F_104332) - N_104284__F_104328 => N_104284__F_104332 - N_104357__F_104461 => N_104357__F_104484 - N_104357__F_104462 => N_104357__F_104485 - N_104357__F_104472 => N_104357__F_104490 - N_104357__F_104473 => N_104357__F_104490 - N_104357__F_104474 => N_104357__F_104491 - !(N_104357__F_104499 & N_104357__F_104402) - N_104357__F_104505 => N_104357__F_104405 - N_104357__F_104509 => N_104357__F_104405 - N_104357__F_104516 => N_104357__F_104487 - N_104357__F_104517 => N_104357__F_104488 - !(N_104536__I_104551_i_F_104555 & N_104536__I_104566_i_F_104570) - N_104536__I_104551_i_F_104555 => N_104649__F_104771 - !(N_104536__I_104566_i_F_104570 & N_104536__I_104551_i_F_104555) - N_104536__I_104566_i_F_104570 => N_104649__F_104785 - N_104536__I_104596_i_F_104600 => N_104649__F_104771 - N_104536__I_104611_i_F_104615 => N_104649__F_104785 - N_100000__I_101285_i_F_101337 => N_100000__I_101285_i_F_101379 - N_100000__I_101285_i_F_101340 => N_100000__I_101285_i_F_101382 - N_100000__I_101285_i_F_101346 => N_100000__I_101285_i_F_101364 - N_100000__I_101285_i_F_101349 => N_100000__I_101285_i_F_101367 - N_100000__I_101285_i_F_101352 => N_100000__I_101285_i_F_101373 - N_100000__I_101285_i_F_101355 => N_100000__I_101285_i_F_101370 - N_100000__I_101405_i_F_101457 => N_100000__I_101405_i_F_101499 - N_100000__I_101405_i_F_101460 => N_100000__I_101405_i_F_101502 - N_100000__I_101405_i_F_101466 => N_100000__I_101405_i_F_101484 - N_100000__I_101405_i_F_101469 => N_100000__I_101405_i_F_101487 - N_100000__I_101405_i_F_101472 => N_100000__I_101405_i_F_101493 - N_100000__I_101405_i_F_101475 => N_100000__I_101405_i_F_101490 - N_100000__I_101525_i_F_101577 => N_100000__I_101525_i_F_101619 - N_100000__I_101525_i_F_101580 => N_100000__I_101525_i_F_101622 - N_100000__I_101525_i_F_101586 => N_100000__I_101525_i_F_101604 - N_100000__I_101525_i_F_101589 => N_100000__I_101525_i_F_101607 - N_100000__I_101525_i_F_101592 => N_100000__I_101525_i_F_101613 - N_100000__I_101525_i_F_101595 => N_100000__I_101525_i_F_101610 - N_100000__I_101645_i_F_101697 => N_100000__I_101645_i_F_101739 - N_100000__I_101645_i_F_101700 => N_100000__I_101645_i_F_101742 - N_100000__I_101645_i_F_101706 => N_100000__I_101645_i_F_101724 - N_100000__I_101645_i_F_101709 => N_100000__I_101645_i_F_101727 - N_100000__I_101645_i_F_101712 => N_100000__I_101645_i_F_101733 - N_100000__I_101645_i_F_101715 => N_100000__I_101645_i_F_101730 - N_102385__F_102388 => N_102385__F_102428 - N_102385__F_102388 => N_102385__F_102434 - N_102385__F_102388 => N_102385__F_102439 - N_102385__F_102388 => N_102385__F_102444 - N_102385__F_102388 => N_102385__F_102408 - N_102385__F_102388 => N_102385__F_102457 - N_102385__F_102388 => N_102385__F_102487 - N_102385__F_102388 => N_102385__F_102466 - N_102385__F_102388 => N_102385__F_102491 - N_102385__F_102388 => N_102385__F_102474 - N_102385__F_102388 => N_102385__F_102453 - N_102385__F_102388 => N_102385__F_102448 - N_102385__F_102388 => N_102385__F_102476 - N_102385__F_102388 => N_102385__F_102482 - N_102385__F_102389 => N_102385__F_102430 - N_102385__F_102389 => N_102385__F_102434 - N_102385__F_102389 => N_102385__F_102439 - N_102385__F_102389 => N_102385__F_102444 - N_102385__F_102389 => N_102385__F_102409 - N_102385__F_102389 => N_102385__F_102453 - N_102385__F_102389 => N_102385__F_102457 - N_102385__F_102389 => N_102385__F_102467 - N_102385__F_102389 => N_102385__F_102474 - N_102385__F_102389 => N_102385__F_102476 - N_102385__F_102389 => N_102385__F_102482 - N_102385__F_102389 => N_102385__F_102487 - N_102385__F_102389 => N_102385__F_102448 - N_102385__F_102389 => N_102385__F_102491 - N_102385__F_102390 => N_102385__F_102410 - N_102385__F_102390 => N_102385__F_102428 - N_102385__F_102390 => N_102385__F_102434 - N_102385__F_102390 => N_102385__F_102439 - N_102385__F_102390 => N_102385__F_102444 - N_102385__F_102390 => N_102385__F_102447 - N_102385__F_102390 => N_102385__F_102453 - N_102385__F_102390 => N_102385__F_102458 - N_102385__F_102390 => N_102385__F_102466 - N_102385__F_102390 => N_102385__F_102474 - N_102385__F_102390 => N_102385__F_102481 - N_102385__F_102390 => N_102385__F_102491 - !(N_102385__F_102390 & N_102385__F_102420) - !(N_102385__F_102390 & N_102385__F_102487) - !(N_102385__F_102390 & N_102385__F_102488) - !(N_102385__F_102390 & N_102385__F_102500) - N_102385__F_102391 => N_102385__F_102487 - N_102385__F_102391 => N_102385__F_102413 - N_102385__F_102391 => N_102385__F_102429 - N_102385__F_102391 => N_102385__F_102436 - N_102385__F_102391 => N_102385__F_102441 - N_102385__F_102391 => N_102385__F_102444 - !(N_102385__F_102391 & N_102385__F_102451) - N_102385__F_102391 => N_102385__F_102458 - N_102385__F_102391 => N_102385__F_102467 - N_102385__F_102391 => N_102385__F_102470 - N_102385__F_102391 => N_102385__F_102477 - N_102385__F_102391 => N_102385__F_102481 - N_102385__F_102391 => N_102385__F_102492 - N_102385__F_102392 => N_102385__F_102413 - !(N_102385__F_102392 & N_102385__F_102420) - N_102385__F_102392 => N_102385__F_102429 - N_102385__F_102392 => N_102385__F_102436 - N_102385__F_102392 => N_102385__F_102441 - N_102385__F_102392 => N_102385__F_102444 - N_102385__F_102392 => N_102385__F_102451 - N_102385__F_102392 => N_102385__F_102459 - N_102385__F_102392 => N_102385__F_102468 - N_102385__F_102392 => N_102385__F_102471 - N_102385__F_102392 => N_102385__F_102477 - N_102385__F_102392 => N_102385__F_102481 - N_102385__F_102392 => N_102385__F_102487 - N_102385__F_102392 => N_102385__F_102493 - N_102385__F_102393 => N_102385__F_102414 - N_102385__F_102393 => N_102385__F_102429 - N_102385__F_102393 => N_102385__F_102436 - N_102385__F_102393 => N_102385__F_102441 - N_102385__F_102393 => N_102385__F_102444 - !(N_102385__F_102393 & N_102385__F_102451) - !(N_102385__F_102393 & N_102385__F_102447) - N_102385__F_102393 => N_102385__F_102454 - N_102385__F_102393 => N_102385__F_102457 - N_102385__F_102393 => N_102385__F_102467 - N_102385__F_102393 => N_102385__F_102474 - N_102385__F_102393 => N_102385__F_102477 - N_102385__F_102393 => N_102385__F_102481 - N_102385__F_102393 => N_102385__F_102487 - N_102385__F_102393 => N_102385__F_102492 - N_102385__F_102394 => N_102385__F_102496 - N_102385__F_102394 => N_102385__F_102414 - !(N_102385__F_102394 & N_102385__F_102420) - N_102385__F_102394 => N_102385__F_102429 - N_102385__F_102394 => N_102385__F_102436 - N_102385__F_102394 => N_102385__F_102441 - N_102385__F_102394 => N_102385__F_102444 - N_102385__F_102394 => N_102385__F_102460 - N_102385__F_102394 => N_102385__F_102468 - N_102385__F_102394 => N_102385__F_102472 - N_102385__F_102394 => N_102385__F_102477 - N_102385__F_102394 => N_102385__F_102481 - N_102385__F_102394 => N_102385__F_102487 - N_102385__F_102394 => N_102385__F_102496 - N_102385__F_102394 => N_102385__F_102454 - !(N_102385__F_102394 & N_102385__F_102447) - !(N_102385__F_102394 & N_102385__F_102451) - N_102385__F_102394 => N_102385__F_102488 - N_102385__F_102394 => N_104687__F_104692 - N_102385__F_102394 => N_104687__F_104695 - N_102385__F_102395 => N_102385__F_102416 - N_102385__F_102395 => N_102385__F_102431 - N_102385__F_102395 => N_102385__F_102436 - N_102385__F_102395 => N_102385__F_102441 - N_102385__F_102395 => N_102385__F_102444 - !(N_102385__F_102395 & N_102385__F_102451) - N_102385__F_102395 => N_102385__F_102457 - N_102385__F_102395 => N_102385__F_102467 - N_102385__F_102395 => N_102385__F_102470 - N_102385__F_102395 => N_102385__F_102478 - N_102385__F_102395 => N_102385__F_102481 - N_102385__F_102395 => N_102385__F_102487 - N_102385__F_102395 => N_102385__F_102492 - N_102385__F_102396 => N_102385__F_102416 - N_102385__F_102396 => N_102385__F_102431 - N_102385__F_102396 => N_102385__F_102436 - N_102385__F_102396 => N_102385__F_102441 - N_102385__F_102396 => N_102385__F_102444 - N_102385__F_102396 => N_102385__F_102454 - N_102385__F_102396 => N_102385__F_102451 - N_102385__F_102396 => N_102385__F_102460 - N_102385__F_102396 => N_102385__F_102468 - N_102385__F_102396 => N_102385__F_102472 - N_102385__F_102396 => N_102385__F_102478 - N_102385__F_102396 => N_102385__F_102481 - N_102385__F_102396 => N_102385__F_102487 - N_102385__F_102396 => N_102385__F_102493 - N_102385__F_102397 => N_102385__F_102416 - !(N_102385__F_102397 & N_102385__F_102420) - N_102385__F_102397 => N_102385__F_102431 - N_102385__F_102397 => N_102385__F_102436 - N_102385__F_102397 => N_102385__F_102441 - N_102385__F_102397 => N_102385__F_102444 - !(N_102385__F_102397 & N_102385__F_102447) - N_102385__F_102397 => N_102385__F_102460 - N_102385__F_102397 => N_102385__F_102468 - N_102385__F_102397 => N_102385__F_102472 - N_102385__F_102397 => N_102385__F_102477 - N_102385__F_102397 => N_102385__F_102481 - N_102385__F_102397 => N_102385__F_102487 - N_102385__F_102397 => N_102385__F_102496 - N_102385__F_102397 => N_102385__F_102454 - N_102385__F_102397 => N_102385__F_102488 - N_102385__F_102397 => N_104687__F_104692 - N_102385__F_102397 => N_104687__F_104695 - N_102385__F_102398 => N_102385__F_102416 - !(N_102385__F_102398 & N_102385__F_102420) - N_102385__F_102398 => N_102385__F_102431 - N_102385__F_102398 => N_102385__F_102436 - N_102385__F_102398 => N_102385__F_102441 - !(N_102385__F_102398 & N_102385__F_102451) - N_102385__F_102398 => N_102385__F_102454 - N_102385__F_102398 => N_102385__F_102460 - N_102385__F_102398 => N_102385__F_102468 - N_102385__F_102398 => N_102385__F_102477 - N_102385__F_102398 => N_102385__F_102481 - N_102385__F_102398 => N_102385__F_102487 - N_102385__F_102398 => N_102385__F_102496 - N_102385__F_102399 => N_102385__F_102416 - !(N_102385__F_102399 & N_102385__F_102420) - N_102385__F_102399 => N_102385__F_102431 - N_102385__F_102399 => N_102385__F_102436 - N_102385__F_102399 => N_102385__F_102441 - N_102385__F_102399 => N_102385__F_102444 - !(N_102385__F_102399 & N_102385__F_102447) - N_102385__F_102399 => N_102385__F_102454 - N_102385__F_102399 => N_102385__F_102460 - N_102385__F_102399 => N_102385__F_102468 - N_102385__F_102399 => N_102385__F_102472 - N_102385__F_102399 => N_102385__F_102478 - N_102385__F_102399 => N_102385__F_102481 - !(N_102385__F_102399 & "N_102385__F_102483") - N_102385__F_102399 => N_102385__F_102487 - N_102385__F_102399 => N_102385__F_102493 - N_102385__F_102400 => N_102385__F_102415 - N_102385__F_102400 => N_102385__F_102430 - N_102385__F_102400 => N_102385__F_102437 - N_102385__F_102400 => N_102385__F_102441 - N_102385__F_102400 => N_102385__F_102454 - N_102385__F_102400 => N_102385__F_102457 - N_102385__F_102400 => N_102385__F_102467 - N_102385__F_102400 => N_102385__F_102474 - N_102385__F_102400 => N_102385__F_102478 - N_102385__F_102400 => N_102385__F_102481 - N_102385__F_102400 => N_102385__F_102487 - N_102385__F_102400 => N_102385__F_102492 - N_102385__F_102400 => N_102385__F_102445 - !(N_102385__F_102400 & N_102385__F_102451) - N_102385__F_102401 => N_102385__F_102415 - !(N_102385__F_102401 & N_102385__F_102420) - N_102385__F_102401 => N_102385__F_102431 - N_102385__F_102401 => N_102385__F_102436 - N_102385__F_102401 => N_102385__F_102441 - N_102385__F_102401 => N_102385__F_102444 - !(N_102385__F_102401 & N_102385__F_102447) - N_102385__F_102401 => N_102385__F_102454 - N_102385__F_102401 => N_102385__F_102463 - N_102385__F_102401 => N_102385__F_102468 - N_102385__F_102401 => N_102385__F_102472 - N_102385__F_102401 => N_102385__F_102479 - N_102385__F_102401 => N_102385__F_102481 - N_102385__F_102401 => N_102385__F_102487 - N_102385__F_102401 => N_102385__F_102488 - N_102385__F_102401 => N_102385__F_102499 - N_102385__F_102401 => N_104687__F_104692 - N_102385__F_102401 => N_104687__F_104695 - N_102385__F_102402 => N_102385__F_102415 - !(N_102385__F_102402 & N_102385__F_102421) - N_102385__F_102402 => N_102385__F_102431 - N_102385__F_102402 => N_102385__F_102436 - N_102385__F_102402 => N_102385__F_102441 - !(N_102385__F_102402 & N_102385__F_102451) - !(N_102385__F_102402 & N_102385__F_102450) - !(N_102385__F_102402 & N_102385__F_102448) - N_102385__F_102402 => N_102385__F_102454 - N_102385__F_102402 => N_102385__F_102462 - N_102385__F_102402 => N_102385__F_102467 - N_102385__F_102402 => N_102385__F_102474 - N_102385__F_102402 => N_102385__F_102479 - N_102385__F_102402 => N_102385__F_102481 - N_102385__F_102402 => N_102385__F_102487 - N_102385__F_102402 => N_102385__F_102498 - N_102385__F_102402 => N_102385__F_102444 - N_102385__F_102403 => N_102385__F_102417 - !(N_102385__F_102403 & N_102385__F_102420) - N_102385__F_102403 => N_102385__F_102430 - N_102385__F_102403 => N_102385__F_102434 - N_102385__F_102403 => N_102385__F_102439 - N_102385__F_102403 => N_102385__F_102445 - N_102385__F_102403 => N_102385__F_102447 - N_102385__F_102403 => N_102385__F_102453 - N_102385__F_102403 => N_102385__F_102460 - N_102385__F_102403 => N_102385__F_102468 - N_102385__F_102403 => N_102385__F_102478 - N_102385__F_102403 => N_102385__F_102481 - N_102385__F_102403 => N_102385__F_102487 - N_102385__F_102403 => N_102385__F_102495 - N_102385__F_102403 => N_102385__F_102485 - N_102385__F_102404 => N_102385__F_102417 - !(N_102385__F_102404 & N_102385__F_102420) - N_102385__F_102404 => N_102385__F_102430 - N_102385__F_102404 => N_102385__F_102439 - N_102385__F_102404 => N_102385__F_102434 - N_102385__F_102404 => N_102385__F_102447 - N_102385__F_102404 => N_102385__F_102453 - N_102385__F_102404 => N_102385__F_102460 - N_102385__F_102404 => N_102385__F_102468 - N_102385__F_102404 => N_102385__F_102472 - N_102385__F_102404 => N_102385__F_102478 - N_102385__F_102404 => N_102385__F_102481 - N_102385__F_102404 => N_102385__F_102487 - N_102385__F_102404 => N_102385__F_102488 - N_102385__F_102404 => N_102385__F_102496 - N_102385__F_102404 => N_102385__F_102445 - N_102385__F_102404 => N_104687__F_104692 - N_102385__F_102404 => N_104687__F_104695 - N_104357__F_104503 => N_104357__F_104405 - !(N_102385__F_102444 & N_102385__F_102485) - !(N_102385__F_102445 & N_102385__F_102484) - N_102383__I_102504_i_F_102508 => N_102383__I_102504_i_F_102574 - N_102383__I_102504_i_F_102508 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102508 => N_102383__I_102504_i_F_102622 - N_102383__I_102504_i_F_102508 => N_102383__I_102504_i_F_102634 - N_102383__I_102504_i_F_102511 => N_102383__I_102504_i_F_102580 - N_102383__I_102504_i_F_102511 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102511 => N_102383__I_102504_i_F_102622 - N_102383__I_102504_i_F_102511 => N_102383__I_102504_i_F_102634 - N_102383__I_102504_i_F_102514 => N_102383__I_102504_i_F_102583 - N_102383__I_102504_i_F_102514 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102514 => N_102383__I_102504_i_F_102622 - N_102383__I_102504_i_F_102514 => N_102383__I_102504_i_F_102634 - N_102383__I_102504_i_F_102517 => N_102383__I_102504_i_F_102574 - N_102383__I_102504_i_F_102517 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102517 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102517 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102520 => N_102383__I_102504_i_F_102580 - N_102383__I_102504_i_F_102520 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102520 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102520 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102523 => N_102383__I_102504_i_F_102580 - N_102383__I_102504_i_F_102523 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102523 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102523 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102526 => N_102383__I_102504_i_F_102583 - N_102383__I_102504_i_F_102526 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102526 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102526 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102529 => N_102383__I_102504_i_F_102586 - N_102383__I_102504_i_F_102529 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102529 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102529 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102532 => N_102383__I_102504_i_F_102580 - N_102383__I_102504_i_F_102532 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102532 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102532 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102535 => N_102383__I_102504_i_F_102583 - N_102383__I_102504_i_F_102535 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102535 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102535 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102538 => N_102383__I_102504_i_F_102586 - N_102383__I_102504_i_F_102538 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102538 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102538 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102541 => N_102383__I_102504_i_F_102589 - N_102383__I_102504_i_F_102541 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102541 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102541 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102544 => N_102383__I_102504_i_F_102592 - N_102383__I_102504_i_F_102544 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102544 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102544 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102547 => N_102383__I_102504_i_F_102598 - N_102383__I_102504_i_F_102547 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102547 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102547 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102550 => N_102383__I_102504_i_F_102577 - N_102383__I_102504_i_F_102550 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102550 => N_102383__I_102504_i_F_102622 - N_102383__I_102504_i_F_102550 => N_102383__I_102504_i_F_102634 - N_102383__I_102504_i_F_102553 => N_102383__I_102504_i_F_102586 - N_102383__I_102504_i_F_102553 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102553 => N_102383__I_102504_i_F_102622 - N_102383__I_102504_i_F_102553 => N_102383__I_102504_i_F_102634 - N_102383__I_102504_i_F_102556 => N_102383__I_102504_i_F_102601 - N_102383__I_102504_i_F_102556 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102556 => N_102383__I_102504_i_F_102628 - N_102383__I_102504_i_F_102556 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102559 => N_102383__I_102504_i_F_102604 - N_102383__I_102504_i_F_102559 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102559 => N_102383__I_102504_i_F_102628 - N_102383__I_102504_i_F_102559 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102562 => N_102383__I_102504_i_F_102607 - N_102383__I_102504_i_F_102562 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102562 => N_102383__I_102504_i_F_102628 - N_102383__I_102504_i_F_102562 => N_102383__I_102504_i_F_102637 - N_102383__I_102504_i_F_102565 => N_102383__I_102504_i_F_102583 - N_102383__I_102504_i_F_102565 => N_102383__I_102504_i_F_102613 - N_102383__I_102504_i_F_102565 => N_102383__I_102504_i_F_102625 - N_102383__I_102504_i_F_102565 => N_102383__I_102504_i_F_102637 - N_102383__I_102642_i_F_102646 => N_102383__I_102642_i_F_102712 - N_102383__I_102642_i_F_102646 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102646 => N_102383__I_102642_i_F_102760 - N_102383__I_102642_i_F_102646 => N_102383__I_102642_i_F_102772 - N_102383__I_102642_i_F_102649 => N_102383__I_102642_i_F_102718 - N_102383__I_102642_i_F_102649 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102649 => N_102383__I_102642_i_F_102760 - N_102383__I_102642_i_F_102649 => N_102383__I_102642_i_F_102772 - N_102383__I_102642_i_F_102652 => N_102383__I_102642_i_F_102721 - N_102383__I_102642_i_F_102652 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102652 => N_102383__I_102642_i_F_102760 - N_102383__I_102642_i_F_102652 => N_102383__I_102642_i_F_102772 - N_102383__I_102642_i_F_102655 => N_102383__I_102642_i_F_102712 - N_102383__I_102642_i_F_102655 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102655 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102655 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102658 => N_102383__I_102642_i_F_102718 - N_102383__I_102642_i_F_102658 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102658 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102658 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102661 => N_102383__I_102642_i_F_102718 - N_102383__I_102642_i_F_102661 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102661 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102661 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102664 => N_102383__I_102642_i_F_102721 - N_102383__I_102642_i_F_102664 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102664 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102664 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102667 => N_102383__I_102642_i_F_102724 - N_102383__I_102642_i_F_102667 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102667 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102667 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102670 => N_102383__I_102642_i_F_102718 - N_102383__I_102642_i_F_102670 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102670 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102670 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102673 => N_102383__I_102642_i_F_102721 - N_102383__I_102642_i_F_102673 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102673 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102673 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102676 => N_102383__I_102642_i_F_102724 - N_102383__I_102642_i_F_102676 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102676 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102676 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102679 => N_102383__I_102642_i_F_102727 - N_102383__I_102642_i_F_102679 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102679 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102679 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102682 => N_102383__I_102642_i_F_102730 - N_102383__I_102642_i_F_102682 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102682 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102682 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102685 => N_102383__I_102642_i_F_102736 - N_102383__I_102642_i_F_102685 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102685 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102685 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102688 => N_102383__I_102642_i_F_102715 - N_102383__I_102642_i_F_102688 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102688 => N_102383__I_102642_i_F_102760 - N_102383__I_102642_i_F_102688 => N_102383__I_102642_i_F_102772 - N_102383__I_102642_i_F_102691 => N_102383__I_102642_i_F_102724 - N_102383__I_102642_i_F_102691 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102691 => N_102383__I_102642_i_F_102760 - N_102383__I_102642_i_F_102691 => N_102383__I_102642_i_F_102772 - N_102383__I_102642_i_F_102694 => N_102383__I_102642_i_F_102739 - N_102383__I_102642_i_F_102694 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102694 => N_102383__I_102642_i_F_102766 - N_102383__I_102642_i_F_102694 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102697 => N_102383__I_102642_i_F_102742 - N_102383__I_102642_i_F_102697 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102697 => N_102383__I_102642_i_F_102766 - N_102383__I_102642_i_F_102697 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102700 => N_102383__I_102642_i_F_102745 - N_102383__I_102642_i_F_102700 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102700 => N_102383__I_102642_i_F_102766 - N_102383__I_102642_i_F_102700 => N_102383__I_102642_i_F_102775 - N_102383__I_102642_i_F_102703 => N_102383__I_102642_i_F_102721 - N_102383__I_102642_i_F_102703 => N_102383__I_102642_i_F_102751 - N_102383__I_102642_i_F_102703 => N_102383__I_102642_i_F_102763 - N_102383__I_102642_i_F_102703 => N_102383__I_102642_i_F_102775 - N_102383__I_103300_i_F_103304 => N_102383__I_103300_i_F_103352 - N_102383__I_103300_i_F_103304 => N_102383__I_103300_i_F_103463 - N_102383__I_103300_i_F_103307 => N_102383__I_103300_i_F_103352 - !(N_102383__I_103300_i_F_103307 & N_102383__I_103300_i_F_103466) - N_102383__I_103300_i_F_103310 => N_102383__I_103300_i_F_103352 - N_102383__I_103300_i_F_103310 => N_102383__I_103300_i_F_103463 - N_102383__I_103300_i_F_103313 => N_102383__I_103300_i_F_103463 - N_102383__I_103300_i_F_103313 => N_102383__I_103300_i_F_103352 - !(N_102383__I_103300_i_F_103316 & N_102383__I_103300_i_F_103469) - !(N_102383__I_103300_i_F_103316 & N_102383__I_103300_i_F_103358) - !(N_102383__I_103300_i_F_103316 & N_102383__I_103300_i_F_103361) - !(N_102383__I_103300_i_F_103319 & N_102383__I_103300_i_F_103469) - !(N_102383__I_103300_i_F_103319 & N_102383__I_103300_i_F_103358) - !(N_102383__I_103300_i_F_103319 & N_102383__I_103300_i_F_103361) - N_102383__I_103300_i_F_103322 => N_102383__I_103300_i_F_103361 - N_102383__I_103300_i_F_103322 => N_102383__I_103300_i_F_103463 - N_102383__I_103300_i_F_103325 => N_102383__I_103300_i_F_103358 - N_102383__I_103300_i_F_103325 => N_102383__I_103300_i_F_103463 - N_102383__I_103300_i_F_103328 => N_102383__I_103300_i_F_103352 - N_102383__I_103300_i_F_103328 => N_102383__I_103300_i_F_103463 - N_102383__I_103300_i_F_103331 => N_102383__I_103300_i_F_103352 - N_102383__I_103300_i_F_103331 => N_102383__I_103300_i_F_103463 - N_102383__I_103300_i_F_103334 => N_102383__I_103300_i_F_103355 - N_102383__I_103300_i_F_103334 => N_102383__I_103300_i_F_103466 - !(N_102383__I_103300_i_F_103337 & N_102383__I_103300_i_F_103358) - !(N_102383__I_103300_i_F_103337 & N_102383__I_103300_i_F_103361) - !(N_102383__I_103300_i_F_103337 & N_102383__I_103300_i_F_103469) - !(N_102383__I_103300_i_F_103340 & N_102383__I_103300_i_F_103358) - !(N_102383__I_103300_i_F_103340 & N_102383__I_103300_i_F_103361) - !(N_102383__I_103300_i_F_103340 & N_102383__I_103300_i_F_103469) - N_102383__I_103300_i_F_103343 => N_102383__I_103300_i_F_103361 - N_102383__I_103300_i_F_103343 => N_102383__I_103300_i_F_103463 - N_102383__I_103546_i_F_103550 => N_102383__I_103546_i_F_103598 - N_102383__I_103546_i_F_103550 => N_102383__I_103546_i_F_103709 - N_102383__I_103546_i_F_103553 => N_102383__I_103546_i_F_103598 - !(N_102383__I_103546_i_F_103553 & N_102383__I_103546_i_F_103712) - N_102383__I_103546_i_F_103556 => N_102383__I_103546_i_F_103598 - N_102383__I_103546_i_F_103556 => N_102383__I_103546_i_F_103709 - N_102383__I_103546_i_F_103559 => N_102383__I_103546_i_F_103709 - N_102383__I_103546_i_F_103559 => N_102383__I_103546_i_F_103598 - !(N_102383__I_103546_i_F_103562 & N_102383__I_103546_i_F_103715) - !(N_102383__I_103546_i_F_103562 & N_102383__I_103546_i_F_103604) - !(N_102383__I_103546_i_F_103562 & N_102383__I_103546_i_F_103607) - !(N_102383__I_103546_i_F_103565 & N_102383__I_103546_i_F_103715) - !(N_102383__I_103546_i_F_103565 & N_102383__I_103546_i_F_103604) - !(N_102383__I_103546_i_F_103565 & N_102383__I_103546_i_F_103607) - N_102383__I_103546_i_F_103568 => N_102383__I_103546_i_F_103607 - N_102383__I_103546_i_F_103568 => N_102383__I_103546_i_F_103709 - N_102383__I_103546_i_F_103571 => N_102383__I_103546_i_F_103604 - N_102383__I_103546_i_F_103571 => N_102383__I_103546_i_F_103709 - N_102383__I_103546_i_F_103574 => N_102383__I_103546_i_F_103598 - N_102383__I_103546_i_F_103574 => N_102383__I_103546_i_F_103709 - N_102383__I_103546_i_F_103577 => N_102383__I_103546_i_F_103598 - N_102383__I_103546_i_F_103577 => N_102383__I_103546_i_F_103709 - N_102383__I_103546_i_F_103580 => N_102383__I_103546_i_F_103601 - N_102383__I_103546_i_F_103580 => N_102383__I_103546_i_F_103712 - !(N_102383__I_103546_i_F_103583 & N_102383__I_103546_i_F_103604) - !(N_102383__I_103546_i_F_103583 & N_102383__I_103546_i_F_103607) - !(N_102383__I_103546_i_F_103583 & N_102383__I_103546_i_F_103715) - !(N_102383__I_103546_i_F_103586 & N_102383__I_103546_i_F_103604) - !(N_102383__I_103546_i_F_103586 & N_102383__I_103546_i_F_103607) - !(N_102383__I_103546_i_F_103586 & N_102383__I_103546_i_F_103715) - N_102383__I_103546_i_F_103589 => N_102383__I_103546_i_F_103607 - N_102383__I_103546_i_F_103589 => N_102383__I_103546_i_F_103709 - N_102383__I_103792_i_F_103796 => N_102383__I_103792_i_F_103844 - N_102383__I_103792_i_F_103796 => N_102383__I_103792_i_F_103955 - N_102383__I_103792_i_F_103799 => N_102383__I_103792_i_F_103844 - !(N_102383__I_103792_i_F_103799 & N_102383__I_103792_i_F_103958) - N_102383__I_103792_i_F_103802 => N_102383__I_103792_i_F_103844 - N_102383__I_103792_i_F_103802 => N_102383__I_103792_i_F_103955 - N_102383__I_103792_i_F_103805 => N_102383__I_103792_i_F_103955 - N_102383__I_103792_i_F_103805 => N_102383__I_103792_i_F_103844 - !(N_102383__I_103792_i_F_103808 & N_102383__I_103792_i_F_103961) - !(N_102383__I_103792_i_F_103808 & N_102383__I_103792_i_F_103850) - !(N_102383__I_103792_i_F_103808 & N_102383__I_103792_i_F_103853) - !(N_102383__I_103792_i_F_103811 & N_102383__I_103792_i_F_103961) - !(N_102383__I_103792_i_F_103811 & N_102383__I_103792_i_F_103850) - !(N_102383__I_103792_i_F_103811 & N_102383__I_103792_i_F_103853) - N_102383__I_103792_i_F_103814 => N_102383__I_103792_i_F_103853 - N_102383__I_103792_i_F_103814 => N_102383__I_103792_i_F_103955 - N_102383__I_103792_i_F_103817 => N_102383__I_103792_i_F_103850 - N_102383__I_103792_i_F_103817 => N_102383__I_103792_i_F_103955 - N_102383__I_103792_i_F_103820 => N_102383__I_103792_i_F_103844 - N_102383__I_103792_i_F_103820 => N_102383__I_103792_i_F_103955 - N_102383__I_103792_i_F_103823 => N_102383__I_103792_i_F_103844 - N_102383__I_103792_i_F_103823 => N_102383__I_103792_i_F_103955 - N_102383__I_103792_i_F_103826 => N_102383__I_103792_i_F_103847 - N_102383__I_103792_i_F_103826 => N_102383__I_103792_i_F_103958 - !(N_102383__I_103792_i_F_103829 & N_102383__I_103792_i_F_103850) - !(N_102383__I_103792_i_F_103829 & N_102383__I_103792_i_F_103853) - !(N_102383__I_103792_i_F_103829 & N_102383__I_103792_i_F_103961) - !(N_102383__I_103792_i_F_103832 & N_102383__I_103792_i_F_103850) - !(N_102383__I_103792_i_F_103832 & N_102383__I_103792_i_F_103853) - !(N_102383__I_103792_i_F_103832 & N_102383__I_103792_i_F_103961) - N_102383__I_103792_i_F_103835 => N_102383__I_103792_i_F_103853 - N_102383__I_103792_i_F_103835 => N_102383__I_103792_i_F_103955 - N_102383__I_104038_i_F_104042 => N_102383__I_104038_i_F_104090 - N_102383__I_104038_i_F_104042 => N_102383__I_104038_i_F_104201 - N_102383__I_104038_i_F_104045 => N_102383__I_104038_i_F_104090 - !(N_102383__I_104038_i_F_104045 & N_102383__I_104038_i_F_104204) - N_102383__I_104038_i_F_104048 => N_102383__I_104038_i_F_104090 - N_102383__I_104038_i_F_104048 => N_102383__I_104038_i_F_104201 - N_102383__I_104038_i_F_104051 => N_102383__I_104038_i_F_104201 - N_102383__I_104038_i_F_104051 => N_102383__I_104038_i_F_104090 - !(N_102383__I_104038_i_F_104054 & N_102383__I_104038_i_F_104207) - !(N_102383__I_104038_i_F_104054 & N_102383__I_104038_i_F_104096) - !(N_102383__I_104038_i_F_104054 & N_102383__I_104038_i_F_104099) - !(N_102383__I_104038_i_F_104057 & N_102383__I_104038_i_F_104207) - !(N_102383__I_104038_i_F_104057 & N_102383__I_104038_i_F_104096) - !(N_102383__I_104038_i_F_104057 & N_102383__I_104038_i_F_104099) - N_102383__I_104038_i_F_104060 => N_102383__I_104038_i_F_104099 - N_102383__I_104038_i_F_104060 => N_102383__I_104038_i_F_104201 - N_102383__I_104038_i_F_104063 => N_102383__I_104038_i_F_104096 - N_102383__I_104038_i_F_104063 => N_102383__I_104038_i_F_104201 - N_102383__I_104038_i_F_104066 => N_102383__I_104038_i_F_104090 - N_102383__I_104038_i_F_104066 => N_102383__I_104038_i_F_104201 - N_102383__I_104038_i_F_104069 => N_102383__I_104038_i_F_104090 - N_102383__I_104038_i_F_104069 => N_102383__I_104038_i_F_104201 - N_102383__I_104038_i_F_104072 => N_102383__I_104038_i_F_104093 - N_102383__I_104038_i_F_104072 => N_102383__I_104038_i_F_104204 - !(N_102383__I_104038_i_F_104075 & N_102383__I_104038_i_F_104096) - !(N_102383__I_104038_i_F_104075 & N_102383__I_104038_i_F_104099) - !(N_102383__I_104038_i_F_104075 & N_102383__I_104038_i_F_104207) - !(N_102383__I_104038_i_F_104078 & N_102383__I_104038_i_F_104096) - !(N_102383__I_104038_i_F_104078 & N_102383__I_104038_i_F_104099) - !(N_102383__I_104038_i_F_104078 & N_102383__I_104038_i_F_104207) - N_102383__I_104038_i_F_104081 => N_102383__I_104038_i_F_104099 - N_102383__I_104038_i_F_104081 => N_102383__I_104038_i_F_104201 - !(N_102385__F_102461 & N_102385__F_102464) - !(N_102385__F_102461 & N_102385__F_102460) - N_102383__I_102808_i_F_102815 => N_102383__I_102808_i_F_102824 - N_102383__I_102808_i_F_102815 => N_102383__I_102808_i_F_102839 - N_102383__I_102808_i_F_102815 => N_102383__I_102808_i_F_102830 - N_102383__I_102808_i_F_102818 => N_102383__I_102808_i_F_102824 - N_102383__I_102808_i_F_102818 => N_102383__I_102808_i_F_102842 - N_102383__I_102808_i_F_102818 => N_102383__I_102808_i_F_102833 - N_102383__I_102808_i_F_102818 => N_102383__I_102808_i_F_102887 - N_102383__I_102808_i_F_102881 => N_102383__I_102808_i_F_103001 - !(N_102383__I_102808_i_F_102884 & N_102383__I_102808_i_F_103013) - N_102383__I_102808_i_F_102884 => N_102383__I_102808_i_F_103004 - N_102383__I_102808_i_F_102899 => N_102383__I_102808_i_F_102911 - N_102383__I_102808_i_F_102899 => N_102383__I_102808_i_F_102983 - N_102383__I_102808_i_F_102899 => N_102383__I_102808_i_F_102971 - N_102383__I_102808_i_F_102902 => N_102383__I_102808_i_F_102911 - N_102383__I_102808_i_F_102902 => N_102383__I_102808_i_F_102977 - N_102383__I_102808_i_F_102902 => N_102383__I_102808_i_F_102962 - N_102383__I_102808_i_F_102905 => N_102383__I_102808_i_F_102911 - N_102383__I_102808_i_F_102905 => N_102383__I_102808_i_F_102980 - N_102383__I_102808_i_F_102905 => N_102383__I_102808_i_F_102965 - N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102815 - N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102902 - N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102851 - N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102920 - N_102383__I_102808_i_F_103010 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102815 - N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102902 - N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102851 - N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102920 - N_102383__I_102808_i_F_103013 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102818 - N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102902 - N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102854 - N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102920 - N_102383__I_102808_i_F_103016 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102818 - N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102902 - N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102854 - N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102920 - N_102383__I_102808_i_F_103019 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102818 - N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102905 - N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102857 - N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102926 - N_102383__I_102808_i_F_103022 => N_102383__I_102808_i_F_102992 - N_102383__I_102808_i_F_103025 => "N_102383__I_102808_i_F_102812" - N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102857 - N_102383__I_102808_i_F_103025 => "N_102383__I_102808_i_F_102896" - N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102992 - N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102818 - N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102926 - N_102383__I_102808_i_F_103025 => N_102383__I_102808_i_F_102905 - N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102899 - N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102815 - N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102851 - N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102929 - N_102383__I_102808_i_F_103028 => N_102383__I_102808_i_F_102992 - N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102815 - N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102899 - N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102851 - N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102929 - N_102383__I_102808_i_F_103031 => N_102383__I_102808_i_F_102992 - N_102383__I_102808_i_F_103034 => N_102383__I_102808_i_F_102815 - N_102383__I_102808_i_F_103034 => N_102383__I_102808_i_F_102902 - N_102383__I_102808_i_F_103034 => N_102383__I_102808_i_F_102920 - N_102383__I_102808_i_F_103034 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_103037 => N_102383__I_102808_i_F_102815 - N_102383__I_102808_i_F_103037 => N_102383__I_102808_i_F_102902 - N_102383__I_102808_i_F_103037 => N_102383__I_102808_i_F_102920 - N_102383__I_102808_i_F_103037 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102818 - N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102857 - N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102905 - N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102926 - N_102383__I_102808_i_F_103040 => N_102383__I_102808_i_F_102992 - N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102818 - N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102857 - N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102905 - N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102926 - N_102383__I_102808_i_F_103043 => N_102383__I_102808_i_F_102992 - N_102383__I_102808_i_F_103046 => "N_102383__I_102808_i_F_102812" - N_102383__I_102808_i_F_103046 => N_102383__I_102808_i_F_102857 - N_102383__I_102808_i_F_103046 => N_102383__I_102808_i_F_102905 - N_102383__I_102808_i_F_103046 => N_102383__I_102808_i_F_102992 - N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102815 - N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102851 - N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102899 - N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102929 - N_102383__I_102808_i_F_103049 => N_102383__I_102808_i_F_102992 - N_102383__I_103054_i_F_103061 => N_102383__I_103054_i_F_103070 - N_102383__I_103054_i_F_103061 => N_102383__I_103054_i_F_103085 - N_102383__I_103054_i_F_103061 => N_102383__I_103054_i_F_103076 - N_102383__I_103054_i_F_103064 => N_102383__I_103054_i_F_103070 - N_102383__I_103054_i_F_103064 => N_102383__I_103054_i_F_103088 - N_102383__I_103054_i_F_103064 => N_102383__I_103054_i_F_103079 - N_102383__I_103054_i_F_103064 => N_102383__I_103054_i_F_103133 - N_102383__I_103054_i_F_103127 => N_102383__I_103054_i_F_103247 - !(N_102383__I_103054_i_F_103130 & N_102383__I_103054_i_F_103259) - N_102383__I_103054_i_F_103130 => N_102383__I_103054_i_F_103250 - N_102383__I_103054_i_F_103145 => N_102383__I_103054_i_F_103157 - N_102383__I_103054_i_F_103145 => N_102383__I_103054_i_F_103229 - N_102383__I_103054_i_F_103145 => N_102383__I_103054_i_F_103217 - N_102383__I_103054_i_F_103148 => N_102383__I_103054_i_F_103157 - N_102383__I_103054_i_F_103148 => N_102383__I_103054_i_F_103223 - N_102383__I_103054_i_F_103148 => N_102383__I_103054_i_F_103208 - N_102383__I_103054_i_F_103151 => N_102383__I_103054_i_F_103157 - N_102383__I_103054_i_F_103151 => N_102383__I_103054_i_F_103226 - N_102383__I_103054_i_F_103151 => N_102383__I_103054_i_F_103211 - N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103148 - N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103097 - N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103166 - N_102383__I_103054_i_F_103256 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103148 - N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103097 - N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103166 - N_102383__I_103054_i_F_103259 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103064 - N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103148 - N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103100 - N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103166 - N_102383__I_103054_i_F_103262 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103064 - N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103148 - N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103100 - N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103166 - N_102383__I_103054_i_F_103265 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103064 - N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103151 - N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103103 - N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103172 - N_102383__I_103054_i_F_103268 => N_102383__I_103054_i_F_103238 - N_102383__I_103054_i_F_103271 => "N_102383__I_103054_i_F_103058" - N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103103 - N_102383__I_103054_i_F_103271 => "N_102383__I_103054_i_F_103142" - N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103238 - N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103148 - N_102383__I_103054_i_F_103271 => N_102383__I_103054_i_F_103169 - N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103145 - N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103097 - N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103175 - N_102383__I_103054_i_F_103274 => N_102383__I_103054_i_F_103238 - N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103145 - N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103097 - N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103175 - N_102383__I_103054_i_F_103277 => N_102383__I_103054_i_F_103238 - N_102383__I_103054_i_F_103280 => N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103280 => N_102383__I_103054_i_F_103148 - N_102383__I_103054_i_F_103280 => N_102383__I_103054_i_F_103166 - N_102383__I_103054_i_F_103280 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103283 => N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103283 => N_102383__I_103054_i_F_103148 - N_102383__I_103054_i_F_103283 => N_102383__I_103054_i_F_103166 - N_102383__I_103054_i_F_103283 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103064 - N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103103 - N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103151 - N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103172 - N_102383__I_103054_i_F_103286 => N_102383__I_103054_i_F_103238 - N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103064 - N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103103 - N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103151 - N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103172 - N_102383__I_103054_i_F_103289 => N_102383__I_103054_i_F_103238 - N_102383__I_103054_i_F_103292 => "N_102383__I_103054_i_F_103058" - N_102383__I_103054_i_F_103292 => N_102383__I_103054_i_F_103103 - N_102383__I_103054_i_F_103292 => N_102383__I_103054_i_F_103151 - N_102383__I_103054_i_F_103292 => N_102383__I_103054_i_F_103238 - N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103061 - N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103097 - N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103145 - N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103175 - N_102383__I_103054_i_F_103295 => N_102383__I_103054_i_F_103238 - N_102383__I_103300_i_F_103352 => N_102383__I_103300_i_F_103442 - N_102383__I_103300_i_F_103352 => N_102383__I_103300_i_F_103391 - N_102383__I_103300_i_F_103352 => N_102383__I_103300_i_F_103433 - !(N_102383__I_103300_i_F_103352 & N_102383__I_103300_i_F_103367) - !(N_102383__I_103300_i_F_103352 & N_102383__I_103300_i_F_103379) - !(N_102383__I_103300_i_F_103352 & N_102383__I_103300_i_F_103382) - N_102383__I_103300_i_F_103352 => N_102383__I_103300_i_F_103451 - N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103442 - N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103433 - N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103397 - N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103367 - N_102383__I_103300_i_F_103355 => N_102383__I_103300_i_F_103451 - N_102383__I_103300_i_F_103358 => N_102383__I_103300_i_F_103433 - N_102383__I_103300_i_F_103358 => N_102383__I_103300_i_F_103394 - N_102383__I_103300_i_F_103358 => N_102383__I_103300_i_F_103445 - !(N_102383__I_103300_i_F_103358 & N_102383__I_103300_i_F_103367) - !(N_102383__I_103300_i_F_103358 & N_102383__I_103300_i_F_103370) - !(N_102383__I_103300_i_F_103358 & N_102383__I_103300_i_F_103373) - !(N_102383__I_103300_i_F_103358 & N_102383__I_103300_i_F_103376) - !(N_102383__I_103300_i_F_103358 & "N_102383__I_103300_i_F_103448") - N_102383__I_103300_i_F_103361 => N_102383__I_103300_i_F_103436 - N_102383__I_103300_i_F_103361 => N_102383__I_103300_i_F_103445 - N_102383__I_103300_i_F_103361 => N_102383__I_103300_i_F_103391 - !(N_102383__I_103300_i_F_103361 & N_102383__I_103300_i_F_103367) - !(N_102383__I_103300_i_F_103361 & N_102383__I_103300_i_F_103370) - !(N_102383__I_103300_i_F_103361 & N_102383__I_103300_i_F_103373) - !(N_102383__I_103300_i_F_103361 & N_102383__I_103300_i_F_103376) - !(N_102383__I_103300_i_F_103361 & "N_102383__I_103300_i_F_103448") - N_102383__I_103300_i_F_103463 => N_102383__I_103300_i_F_103541 - N_102383__I_103300_i_F_103463 => N_102383__I_103300_i_F_103493 - N_102383__I_103300_i_F_103463 => N_102383__I_103300_i_F_103535 - !(N_102383__I_103300_i_F_103463 & N_102383__I_103300_i_F_103475) - N_102383__I_103300_i_F_103466 => N_102383__I_103300_i_F_103541 - N_102383__I_103300_i_F_103466 => N_102383__I_103300_i_F_103535 - N_102383__I_103300_i_F_103466 => N_102383__I_103300_i_F_103499 - N_102383__I_103300_i_F_103466 => N_102383__I_103300_i_F_103475 - N_102383__I_103300_i_F_103469 => N_102383__I_103300_i_F_103541 - N_102383__I_103300_i_F_103469 => N_102383__I_103300_i_F_103496 - N_102383__I_103300_i_F_103469 => N_102383__I_103300_i_F_103535 - !(N_102383__I_103300_i_F_103469 & N_102383__I_103300_i_F_103475) - N_102383__I_103546_i_F_103598 => N_102383__I_103546_i_F_103688 - N_102383__I_103546_i_F_103598 => N_102383__I_103546_i_F_103637 - N_102383__I_103546_i_F_103598 => N_102383__I_103546_i_F_103679 - !(N_102383__I_103546_i_F_103598 & N_102383__I_103546_i_F_103613) - !(N_102383__I_103546_i_F_103598 & N_102383__I_103546_i_F_103625) - !(N_102383__I_103546_i_F_103598 & N_102383__I_103546_i_F_103628) - N_102383__I_103546_i_F_103598 => N_102383__I_103546_i_F_103697 - N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103688 - N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103679 - N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103643 - N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103613 - N_102383__I_103546_i_F_103601 => N_102383__I_103546_i_F_103697 - N_102383__I_103546_i_F_103604 => N_102383__I_103546_i_F_103679 - N_102383__I_103546_i_F_103604 => N_102383__I_103546_i_F_103640 - N_102383__I_103546_i_F_103604 => N_102383__I_103546_i_F_103691 - !(N_102383__I_103546_i_F_103604 & N_102383__I_103546_i_F_103613) - !(N_102383__I_103546_i_F_103604 & N_102383__I_103546_i_F_103616) - !(N_102383__I_103546_i_F_103604 & N_102383__I_103546_i_F_103619) - !(N_102383__I_103546_i_F_103604 & N_102383__I_103546_i_F_103622) - !(N_102383__I_103546_i_F_103604 & "N_102383__I_103546_i_F_103694") - N_102383__I_103546_i_F_103607 => N_102383__I_103546_i_F_103682 - N_102383__I_103546_i_F_103607 => N_102383__I_103546_i_F_103691 - N_102383__I_103546_i_F_103607 => N_102383__I_103546_i_F_103637 - !(N_102383__I_103546_i_F_103607 & N_102383__I_103546_i_F_103613) - !(N_102383__I_103546_i_F_103607 & N_102383__I_103546_i_F_103616) - !(N_102383__I_103546_i_F_103607 & N_102383__I_103546_i_F_103619) - !(N_102383__I_103546_i_F_103607 & N_102383__I_103546_i_F_103622) - !(N_102383__I_103546_i_F_103607 & "N_102383__I_103546_i_F_103694") - N_102383__I_103546_i_F_103709 => N_102383__I_103546_i_F_103787 - N_102383__I_103546_i_F_103709 => N_102383__I_103546_i_F_103739 - N_102383__I_103546_i_F_103709 => N_102383__I_103546_i_F_103781 - !(N_102383__I_103546_i_F_103709 & N_102383__I_103546_i_F_103721) - N_102383__I_103546_i_F_103712 => N_102383__I_103546_i_F_103787 - N_102383__I_103546_i_F_103712 => N_102383__I_103546_i_F_103781 - N_102383__I_103546_i_F_103712 => N_102383__I_103546_i_F_103745 - N_102383__I_103546_i_F_103712 => N_102383__I_103546_i_F_103721 - N_102383__I_103546_i_F_103715 => N_102383__I_103546_i_F_103787 - N_102383__I_103546_i_F_103715 => N_102383__I_103546_i_F_103742 - N_102383__I_103546_i_F_103715 => N_102383__I_103546_i_F_103781 - !(N_102383__I_103546_i_F_103715 & N_102383__I_103546_i_F_103721) - N_102383__I_103792_i_F_103844 => N_102383__I_103792_i_F_103934 - N_102383__I_103792_i_F_103844 => N_102383__I_103792_i_F_103883 - N_102383__I_103792_i_F_103844 => N_102383__I_103792_i_F_103925 - !(N_102383__I_103792_i_F_103844 & N_102383__I_103792_i_F_103859) - !(N_102383__I_103792_i_F_103844 & N_102383__I_103792_i_F_103871) - !(N_102383__I_103792_i_F_103844 & N_102383__I_103792_i_F_103874) - N_102383__I_103792_i_F_103844 => N_102383__I_103792_i_F_103943 - N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103934 - N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103925 - N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103889 - N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103859 - N_102383__I_103792_i_F_103847 => N_102383__I_103792_i_F_103943 - N_102383__I_103792_i_F_103850 => N_102383__I_103792_i_F_103925 - N_102383__I_103792_i_F_103850 => N_102383__I_103792_i_F_103886 - N_102383__I_103792_i_F_103850 => N_102383__I_103792_i_F_103937 - !(N_102383__I_103792_i_F_103850 & N_102383__I_103792_i_F_103859) - !(N_102383__I_103792_i_F_103850 & N_102383__I_103792_i_F_103862) - !(N_102383__I_103792_i_F_103850 & N_102383__I_103792_i_F_103865) - !(N_102383__I_103792_i_F_103850 & N_102383__I_103792_i_F_103868) - !(N_102383__I_103792_i_F_103850 & "N_102383__I_103792_i_F_103940") - N_102383__I_103792_i_F_103853 => N_102383__I_103792_i_F_103928 - N_102383__I_103792_i_F_103853 => N_102383__I_103792_i_F_103937 - N_102383__I_103792_i_F_103853 => N_102383__I_103792_i_F_103883 - !(N_102383__I_103792_i_F_103853 & N_102383__I_103792_i_F_103859) - !(N_102383__I_103792_i_F_103853 & N_102383__I_103792_i_F_103862) - !(N_102383__I_103792_i_F_103853 & N_102383__I_103792_i_F_103865) - !(N_102383__I_103792_i_F_103853 & N_102383__I_103792_i_F_103868) - !(N_102383__I_103792_i_F_103853 & "N_102383__I_103792_i_F_103940") - N_102383__I_103792_i_F_103955 => N_102383__I_103792_i_F_104033 - N_102383__I_103792_i_F_103955 => N_102383__I_103792_i_F_103985 - N_102383__I_103792_i_F_103955 => N_102383__I_103792_i_F_104027 - !(N_102383__I_103792_i_F_103955 & N_102383__I_103792_i_F_103967) - N_102383__I_103792_i_F_103958 => N_102383__I_103792_i_F_104033 - N_102383__I_103792_i_F_103958 => N_102383__I_103792_i_F_104027 - N_102383__I_103792_i_F_103958 => N_102383__I_103792_i_F_103991 - N_102383__I_103792_i_F_103958 => N_102383__I_103792_i_F_103967 - N_102383__I_103792_i_F_103961 => N_102383__I_103792_i_F_104033 - N_102383__I_103792_i_F_103961 => N_102383__I_103792_i_F_103988 - N_102383__I_103792_i_F_103961 => N_102383__I_103792_i_F_104027 - !(N_102383__I_103792_i_F_103961 & N_102383__I_103792_i_F_103967) - N_102383__I_104038_i_F_104090 => N_102383__I_104038_i_F_104180 - N_102383__I_104038_i_F_104090 => N_102383__I_104038_i_F_104129 - N_102383__I_104038_i_F_104090 => N_102383__I_104038_i_F_104171 - !(N_102383__I_104038_i_F_104090 & N_102383__I_104038_i_F_104105) - !(N_102383__I_104038_i_F_104090 & N_102383__I_104038_i_F_104117) - !(N_102383__I_104038_i_F_104090 & N_102383__I_104038_i_F_104120) - N_102383__I_104038_i_F_104090 => N_102383__I_104038_i_F_104189 - N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104180 - N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104171 - N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104135 - N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104105 - N_102383__I_104038_i_F_104093 => N_102383__I_104038_i_F_104189 - N_102383__I_104038_i_F_104096 => N_102383__I_104038_i_F_104171 - N_102383__I_104038_i_F_104096 => N_102383__I_104038_i_F_104132 - N_102383__I_104038_i_F_104096 => N_102383__I_104038_i_F_104183 - !(N_102383__I_104038_i_F_104096 & N_102383__I_104038_i_F_104105) - !(N_102383__I_104038_i_F_104096 & N_102383__I_104038_i_F_104108) - !(N_102383__I_104038_i_F_104096 & N_102383__I_104038_i_F_104111) - !(N_102383__I_104038_i_F_104096 & N_102383__I_104038_i_F_104114) - !(N_102383__I_104038_i_F_104096 & "N_102383__I_104038_i_F_104186") - N_102383__I_104038_i_F_104099 => N_102383__I_104038_i_F_104174 - N_102383__I_104038_i_F_104099 => N_102383__I_104038_i_F_104183 - N_102383__I_104038_i_F_104099 => N_102383__I_104038_i_F_104129 - !(N_102383__I_104038_i_F_104099 & N_102383__I_104038_i_F_104105) - !(N_102383__I_104038_i_F_104099 & N_102383__I_104038_i_F_104108) - !(N_102383__I_104038_i_F_104099 & N_102383__I_104038_i_F_104111) - !(N_102383__I_104038_i_F_104099 & N_102383__I_104038_i_F_104114) - !(N_102383__I_104038_i_F_104099 & "N_102383__I_104038_i_F_104186") - N_102383__I_104038_i_F_104201 => N_102383__I_104038_i_F_104279 - N_102383__I_104038_i_F_104201 => N_102383__I_104038_i_F_104231 - N_102383__I_104038_i_F_104201 => N_102383__I_104038_i_F_104273 - !(N_102383__I_104038_i_F_104201 & N_102383__I_104038_i_F_104213) - N_102383__I_104038_i_F_104204 => N_102383__I_104038_i_F_104279 - N_102383__I_104038_i_F_104204 => N_102383__I_104038_i_F_104273 - N_102383__I_104038_i_F_104204 => N_102383__I_104038_i_F_104237 - N_102383__I_104038_i_F_104204 => N_102383__I_104038_i_F_104213 - N_102383__I_104038_i_F_104207 => N_102383__I_104038_i_F_104279 - N_102383__I_104038_i_F_104207 => N_102383__I_104038_i_F_104234 - N_102383__I_104038_i_F_104207 => N_102383__I_104038_i_F_104273 - !(N_102383__I_104038_i_F_104207 & N_102383__I_104038_i_F_104213) - N_102383__I_102808_i_F_102965 => N_102383__I_102808_i_F_102980 - N_102383__I_102808_i_F_103001 => N_102383__I_102808_i_F_102881 - !(N_102383__I_102808_i_F_103004 & N_102383__I_102808_i_F_103013) - N_102383__I_102808_i_F_103004 => N_102383__I_102808_i_F_102884 - N_102383__I_103054_i_F_103211 => N_102383__I_103054_i_F_103226 - N_102383__I_103054_i_F_103247 => N_102383__I_103054_i_F_103127 - !(N_102383__I_103054_i_F_103250 & N_102383__I_103054_i_F_103259) - N_102383__I_103054_i_F_103250 => N_102383__I_103054_i_F_103130 - N_102383__I_103300_i_F_103391 => N_102383__I_103300_i_F_103403 - N_102383__I_103300_i_F_103391 => N_102383__I_103300_i_F_103415 - N_102383__I_103300_i_F_103391 => N_102383__I_103300_i_F_103421 - N_102383__I_103300_i_F_103391 => N_102383__I_103300_i_F_103427 - N_102383__I_103300_i_F_103394 => N_102383__I_103300_i_F_103403 - N_102383__I_103300_i_F_103394 => N_102383__I_103300_i_F_103415 - N_102383__I_103300_i_F_103394 => N_102383__I_103300_i_F_103421 - !(N_102383__I_103300_i_F_103394 & N_102383__I_103300_i_F_103427) - N_102383__I_103300_i_F_103397 => N_102383__I_103300_i_F_103412 - N_102383__I_103300_i_F_103397 => N_102383__I_103300_i_F_103406 - N_102383__I_103300_i_F_103397 => N_102383__I_103300_i_F_103424 - N_102383__I_103300_i_F_103397 => N_102383__I_103300_i_F_103427 - N_102383__I_103300_i_F_103493 => N_102383__I_103300_i_F_103505 - N_102383__I_103300_i_F_103493 => N_102383__I_103300_i_F_103523 - N_102383__I_103300_i_F_103493 => N_102383__I_103300_i_F_103517 - !(N_102383__I_103300_i_F_103493 & N_102383__I_103300_i_F_103529) - N_102383__I_103300_i_F_103496 => N_102383__I_103300_i_F_103505 - N_102383__I_103300_i_F_103496 => N_102383__I_103300_i_F_103517 - N_102383__I_103300_i_F_103496 => N_102383__I_103300_i_F_103523 - N_102383__I_103300_i_F_103496 => N_102383__I_103300_i_F_103529 - N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103514 - N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103508 - N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103514 - N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103526 - N_102383__I_103300_i_F_103499 => N_102383__I_103300_i_F_103535 - !(N_102383__I_103300_i_F_103499 & N_102383__I_103300_i_F_103529) - N_102383__I_103546_i_F_103637 => N_102383__I_103546_i_F_103649 - N_102383__I_103546_i_F_103637 => N_102383__I_103546_i_F_103661 - N_102383__I_103546_i_F_103637 => N_102383__I_103546_i_F_103667 - N_102383__I_103546_i_F_103637 => N_102383__I_103546_i_F_103673 - N_102383__I_103546_i_F_103640 => N_102383__I_103546_i_F_103649 - N_102383__I_103546_i_F_103640 => N_102383__I_103546_i_F_103661 - N_102383__I_103546_i_F_103640 => N_102383__I_103546_i_F_103667 - !(N_102383__I_103546_i_F_103640 & N_102383__I_103546_i_F_103673) - N_102383__I_103546_i_F_103643 => N_102383__I_103546_i_F_103658 - N_102383__I_103546_i_F_103643 => N_102383__I_103546_i_F_103652 - N_102383__I_103546_i_F_103643 => N_102383__I_103546_i_F_103670 - N_102383__I_103546_i_F_103643 => N_102383__I_103546_i_F_103673 - N_102383__I_103546_i_F_103739 => N_102383__I_103546_i_F_103751 - N_102383__I_103546_i_F_103739 => N_102383__I_103546_i_F_103769 - N_102383__I_103546_i_F_103739 => N_102383__I_103546_i_F_103763 - !(N_102383__I_103546_i_F_103739 & N_102383__I_103546_i_F_103775) - N_102383__I_103546_i_F_103742 => N_102383__I_103546_i_F_103751 - N_102383__I_103546_i_F_103742 => N_102383__I_103546_i_F_103763 - N_102383__I_103546_i_F_103742 => N_102383__I_103546_i_F_103769 - N_102383__I_103546_i_F_103742 => N_102383__I_103546_i_F_103775 - N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103760 - N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103754 - N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103760 - N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103772 - N_102383__I_103546_i_F_103745 => N_102383__I_103546_i_F_103781 - !(N_102383__I_103546_i_F_103745 & N_102383__I_103546_i_F_103775) - N_102383__I_103792_i_F_103883 => N_102383__I_103792_i_F_103895 - N_102383__I_103792_i_F_103883 => N_102383__I_103792_i_F_103907 - N_102383__I_103792_i_F_103883 => N_102383__I_103792_i_F_103913 - N_102383__I_103792_i_F_103883 => N_102383__I_103792_i_F_103919 - N_102383__I_103792_i_F_103886 => N_102383__I_103792_i_F_103895 - N_102383__I_103792_i_F_103886 => N_102383__I_103792_i_F_103907 - N_102383__I_103792_i_F_103886 => N_102383__I_103792_i_F_103913 - !(N_102383__I_103792_i_F_103886 & N_102383__I_103792_i_F_103919) - N_102383__I_103792_i_F_103889 => N_102383__I_103792_i_F_103904 - N_102383__I_103792_i_F_103889 => N_102383__I_103792_i_F_103898 - N_102383__I_103792_i_F_103889 => N_102383__I_103792_i_F_103916 - N_102383__I_103792_i_F_103889 => N_102383__I_103792_i_F_103919 - N_102383__I_103792_i_F_103985 => N_102383__I_103792_i_F_103997 - N_102383__I_103792_i_F_103985 => N_102383__I_103792_i_F_104015 - N_102383__I_103792_i_F_103985 => N_102383__I_103792_i_F_104009 - !(N_102383__I_103792_i_F_103985 & N_102383__I_103792_i_F_104021) - N_102383__I_103792_i_F_103988 => N_102383__I_103792_i_F_103997 - N_102383__I_103792_i_F_103988 => N_102383__I_103792_i_F_104009 - N_102383__I_103792_i_F_103988 => N_102383__I_103792_i_F_104015 - N_102383__I_103792_i_F_103988 => N_102383__I_103792_i_F_104021 - N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104006 - N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104000 - N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104006 - N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104018 - N_102383__I_103792_i_F_103991 => N_102383__I_103792_i_F_104027 - !(N_102383__I_103792_i_F_103991 & N_102383__I_103792_i_F_104021) - N_102383__I_104038_i_F_104129 => N_102383__I_104038_i_F_104141 - N_102383__I_104038_i_F_104129 => N_102383__I_104038_i_F_104153 - N_102383__I_104038_i_F_104129 => N_102383__I_104038_i_F_104159 - N_102383__I_104038_i_F_104129 => N_102383__I_104038_i_F_104165 - N_102383__I_104038_i_F_104132 => N_102383__I_104038_i_F_104141 - N_102383__I_104038_i_F_104132 => N_102383__I_104038_i_F_104153 - N_102383__I_104038_i_F_104132 => N_102383__I_104038_i_F_104159 - !(N_102383__I_104038_i_F_104132 & N_102383__I_104038_i_F_104165) - N_102383__I_104038_i_F_104135 => N_102383__I_104038_i_F_104150 - N_102383__I_104038_i_F_104135 => N_102383__I_104038_i_F_104144 - N_102383__I_104038_i_F_104135 => N_102383__I_104038_i_F_104162 - N_102383__I_104038_i_F_104135 => N_102383__I_104038_i_F_104165 - N_102383__I_104038_i_F_104231 => N_102383__I_104038_i_F_104243 - N_102383__I_104038_i_F_104231 => N_102383__I_104038_i_F_104261 - N_102383__I_104038_i_F_104231 => N_102383__I_104038_i_F_104255 - !(N_102383__I_104038_i_F_104231 & N_102383__I_104038_i_F_104267) - N_102383__I_104038_i_F_104234 => N_102383__I_104038_i_F_104243 - N_102383__I_104038_i_F_104234 => N_102383__I_104038_i_F_104255 - N_102383__I_104038_i_F_104234 => N_102383__I_104038_i_F_104261 - N_102383__I_104038_i_F_104234 => N_102383__I_104038_i_F_104267 - N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104252 - N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104246 - N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104252 - N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104264 - N_102383__I_104038_i_F_104237 => N_102383__I_104038_i_F_104273 - !(N_102383__I_104038_i_F_104237 & N_102383__I_104038_i_F_104267) - N_102383__I_102808_i_F_102851 => N_102383__I_102808_i_F_102863 - N_102383__I_102808_i_F_102851 => N_102383__I_102808_i_F_102872 - N_102383__I_102808_i_F_102854 => N_102383__I_102808_i_F_102866 - N_102383__I_102808_i_F_102854 => N_102383__I_102808_i_F_102875 - N_102383__I_102808_i_F_102857 => N_102383__I_102808_i_F_102866 - N_102383__I_102808_i_F_102857 => N_102383__I_102808_i_F_102875 - N_102383__I_102808_i_F_102920 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_102920 => N_102383__I_102808_i_F_102935 - N_102383__I_102808_i_F_102920 => N_102383__I_102808_i_F_102950 - N_102383__I_102808_i_F_102923 => N_102383__I_102808_i_F_102935 - N_102383__I_102808_i_F_102923 => N_102383__I_102808_i_F_102950 - N_102383__I_102808_i_F_102923 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_102926 => N_102383__I_102808_i_F_102989 - N_102383__I_102808_i_F_102926 => N_102383__I_102808_i_F_102938 - N_102383__I_102808_i_F_102926 => N_102383__I_102808_i_F_102953 - N_102383__I_102808_i_F_102929 => N_102383__I_102808_i_F_102944 - N_102383__I_102808_i_F_102929 => N_102383__I_102808_i_F_102956 - N_102383__I_102808_i_F_102929 => N_102383__I_102808_i_F_102992 - N_102383__I_103054_i_F_103097 => N_102383__I_103054_i_F_103109 - N_102383__I_103054_i_F_103097 => N_102383__I_103054_i_F_103118 - N_102383__I_103054_i_F_103100 => N_102383__I_103054_i_F_103112 - N_102383__I_103054_i_F_103100 => N_102383__I_103054_i_F_103121 - N_102383__I_103054_i_F_103103 => N_102383__I_103054_i_F_103112 - N_102383__I_103054_i_F_103103 => N_102383__I_103054_i_F_103121 - N_102383__I_103054_i_F_103166 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103166 => N_102383__I_103054_i_F_103181 - N_102383__I_103054_i_F_103166 => N_102383__I_103054_i_F_103196 - N_102383__I_103054_i_F_103169 => N_102383__I_103054_i_F_103181 - N_102383__I_103054_i_F_103169 => N_102383__I_103054_i_F_103196 - N_102383__I_103054_i_F_103169 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103172 => N_102383__I_103054_i_F_103235 - N_102383__I_103054_i_F_103172 => N_102383__I_103054_i_F_103184 - N_102383__I_103054_i_F_103172 => N_102383__I_103054_i_F_103199 - N_102383__I_103054_i_F_103175 => N_102383__I_103054_i_F_103190 - N_102383__I_103054_i_F_103175 => N_102383__I_103054_i_F_103202 - N_102383__I_103054_i_F_103175 => N_102383__I_103054_i_F_103238 \ No newline at end of file diff --git a/test2.uvl b/test2.uvl deleted file mode 100644 index 65bb8e0..0000000 --- a/test2.uvl +++ /dev/null @@ -1,10 +0,0 @@ -features - x - optional - a - b - c - d - e -constraints - a | b | c | d => e \ No newline at end of file diff --git a/test_composedModel.uvl b/test_composedModel.uvl deleted file mode 100644 index 7ce77e9..0000000 --- a/test_composedModel.uvl +++ /dev/null @@ -1,21 +0,0 @@ -namespace Server - -features - Server {abstract true} - mandatory - FileSystem - or - NTFS - APFS - EXT4 - OperatingSystem {abstract true} - alternative - Windows - macOS - Debian - optional - Logging {log_level 2, default true} - -constraints - Windows => NTFS - macOS => APFS diff --git a/test_singleModel.uvl b/test_singleModel.uvl deleted file mode 100644 index 7ce77e9..0000000 --- a/test_singleModel.uvl +++ /dev/null @@ -1,21 +0,0 @@ -namespace Server - -features - Server {abstract true} - mandatory - FileSystem - or - NTFS - APFS - EXT4 - OperatingSystem {abstract true} - alternative - Windows - macOS - Debian - optional - Logging {log_level 2, default true} - -constraints - Windows => NTFS - macOS => APFS From 7c9dcf6b76495527d789354dac054e131165f0d0 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 23 Jan 2025 09:06:50 +0100 Subject: [PATCH 54/60] refactor: applied code auto-formatting --- .../conversion/ConvertFeatureCardinality.java | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java index 6855dd3..9dbcdb0 100644 --- a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java +++ b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java @@ -78,9 +78,9 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel if (constraintReplacementMap.containsKey(toReplace)) { LiteralConstraint newLiteral = new LiteralConstraint(constraintReplacementMap.get(toReplace)); LiteralConstraint subTreeRootConstraint = new LiteralConstraint(newChild); - newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newLiteral));; + newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newLiteral)); } - }else{ + } else { adaptConstraint(subTreeClone, newConstraint, constraintReplacementMap); LiteralConstraint subTreeRootConstraint = new LiteralConstraint(newChild); newConstraint = new ImplicationConstraint(subTreeRootConstraint, new ParenthesisConstraint(newConstraint)); @@ -111,7 +111,7 @@ private void orAdaptedConstraint(Constraint constraint, Set featuresToRe for (Constraint subPart : constraint.getConstraintSubParts()) { if (subPart instanceof LiteralConstraint) { String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); - if (featuresToReplace.contains(toReplace)){ + if (featuresToReplace.contains(toReplace)) { Feature f = featureModel.getFeatureMap().get(toReplace + "-" + (min == 0 ? 1 : min) + "-1"); Constraint newOr = new LiteralConstraint(f); for (int i = min + 1; i <= max; i++) { @@ -121,7 +121,7 @@ private void orAdaptedConstraint(Constraint constraint, Set featuresToRe } constraint.replaceConstraintSubPart(subPart, new ParenthesisConstraint(newOr)); } - }else { + } else { orAdaptedConstraint(subPart, featuresToReplace, min, max, featureModel); } } @@ -130,7 +130,7 @@ private void orAdaptedConstraint(Constraint constraint, Set featuresToRe private void getAllSubFeatureNamesRecursively(Feature feature, Set names) { names.add(feature.getFeatureName()); for (Group child : feature.getChildren()) { - for(Feature childFeature : child.getFeatures()){ + for (Feature childFeature : child.getFeatures()) { getAllSubFeatureNamesRecursively(childFeature, names); } } @@ -180,10 +180,10 @@ private boolean constraintContains(Constraint constraint, List subTreeF if (subTreeFeatures.contains(feature)) { return true; } - }else if (constraint instanceof ExpressionConstraint) { + } else if (constraint instanceof ExpressionConstraint) { Expression left = ((ExpressionConstraint) constraint).getLeft(); Expression right = ((ExpressionConstraint) constraint).getRight(); - return expressionContains(left,subTreeFeatures) || expressionContains(right,subTreeFeatures); + return expressionContains(left, subTreeFeatures) || expressionContains(right, subTreeFeatures); } for (Constraint subPart : subParts) { @@ -192,7 +192,7 @@ private boolean constraintContains(Constraint constraint, List subTreeF if (subTreeFeatures.contains(feature)) { return true; } - } else if (constraintContains(subPart, subTreeFeatures)){ + } else if (constraintContains(subPart, subTreeFeatures)) { return true; } } @@ -213,7 +213,7 @@ private boolean expressionContains(Expression expression, List subTreeF if (subTreeFeatures.contains(feature)) { return true; } - }else if(expressionContains(subExpression, subTreeFeatures)){ + } else if (expressionContains(subExpression, subTreeFeatures)) { return true; } } @@ -236,7 +236,7 @@ private void adaptConstraint(Feature subTreeRoot, Constraint constraint, Map subParts = constraint.getConstraintSubParts(); for (Constraint subPart : subParts) { if (subPart instanceof LiteralConstraint) { @@ -262,7 +262,7 @@ private void adaptExpression(Expression expression, Map feature literalExpression.setContent(newAttribute); } - }else{ + } else { for (Expression subExpression : expression.getExpressionSubParts()) { adaptExpression(subExpression, featureReplacementMap); } From 997298edd8439135bbf94a98b2c4571c75c64971 Mon Sep 17 00:00:00 2001 From: Stefan Date: Thu, 23 Jan 2025 09:19:49 +0100 Subject: [PATCH 55/60] refactor: changed back to maven dependencies --- pom.xml | 21 ++++++++------------- 1 file changed, 8 insertions(+), 13 deletions(-) diff --git a/pom.xml b/pom.xml index a5e826f..a0026e5 100644 --- a/pom.xml +++ b/pom.xml @@ -48,8 +48,8 @@ scm:git:git@github.com:Universal-Variability-Language/java-fm-metamodel.git scm:git:git@github.com:Universal-Variability-Language/java-fm-metamodel.git https://github.com/Universal-Variability-Language/java-fm-metamodel - HEAD - + HEAD + @@ -76,6 +76,11 @@ antlr4-runtime 4.13.1 + + io.github.universal-variability-language + uvl-parser + 0.3 + org.junit.jupiter junit-jupiter @@ -87,16 +92,6 @@ guava 31.0.1-jre - - uvl - uvl - 1.0.0 - - - org.antlr - antlr - 3.4.0 - @@ -111,7 +106,7 @@ - de.vill.main.Example + fully.qualified.MainClass From e5687e73fbd0102f5a70cde368778802d3f3df59 Mon Sep 17 00:00:00 2001 From: Chico Sundermann Date: Tue, 28 Jan 2025 16:59:45 +0100 Subject: [PATCH 56/60] Added automatic bracket creation when printing UVL models --- .../model/building/AutomaticBrackets.java | 97 +++++++++++++++++++ .../vill/model/constraint/AndConstraint.java | 5 +- .../constraint/EquivalenceConstraint.java | 9 +- .../constraint/ImplicationConstraint.java | 9 +- .../model/constraint/MultiOrConstraint.java | 3 +- .../vill/model/constraint/OrConstraint.java | 5 +- .../vill/model/expression/AddExpression.java | 5 +- .../vill/model/expression/DivExpression.java | 5 +- .../vill/model/expression/MulExpression.java | 5 +- .../vill/model/expression/SubExpression.java | 5 +- 10 files changed, 125 insertions(+), 23 deletions(-) create mode 100644 src/main/java/de/vill/model/building/AutomaticBrackets.java diff --git a/src/main/java/de/vill/model/building/AutomaticBrackets.java b/src/main/java/de/vill/model/building/AutomaticBrackets.java new file mode 100644 index 0000000..f71b272 --- /dev/null +++ b/src/main/java/de/vill/model/building/AutomaticBrackets.java @@ -0,0 +1,97 @@ +package de.vill.model.building; + +import de.vill.model.constraint.*; +import de.vill.model.expression.*; + +import java.util.HashMap; +import java.util.Map; + +/** + * This class automatically creates brackets for nested constraints to ensure semantic equivalence when printing out the UVL model. + * Precedences are ordered according to ... and ... + * A higher score indicates a higher precedence (i.e., a stronger binding) + * @author Chico Sundermann + */ +public class AutomaticBrackets { + + private AutomaticBrackets() {} + + static Map constraintprecedenceLookup; + + static Map expressionPrecedenceLookup; + + static { + constraintprecedenceLookup = new HashMap<>(); + + // n-ary + constraintprecedenceLookup.put(EquivalenceConstraint.class, 0); + constraintprecedenceLookup.put(ImplicationConstraint.class, 1); + constraintprecedenceLookup.put(OrConstraint.class, 2); + constraintprecedenceLookup.put(MultiOrConstraint.class, 2); + constraintprecedenceLookup.put(AndConstraint.class, 3); + constraintprecedenceLookup.put(GreaterEquationConstraint.class, 4); + constraintprecedenceLookup.put(LowerEquationConstraint.class, 4); + constraintprecedenceLookup.put(GreaterEqualsEquationConstraint.class, 4); + constraintprecedenceLookup.put(LowerEqualsEquationConstraint.class, 4); + constraintprecedenceLookup.put(NotEqualsEquationConstraint.class, 5); + constraintprecedenceLookup.put(EqualEquationConstraint.class, 5); + + // Unary + constraintprecedenceLookup.put(LiteralConstraint.class, 6); + constraintprecedenceLookup.put(NotConstraint.class, 6); + constraintprecedenceLookup.put(ParenthesisConstraint.class, 6); + + expressionPrecedenceLookup = new HashMap<>(); + + // n-ary + expressionPrecedenceLookup.put(AddExpression.class, 0); + expressionPrecedenceLookup.put(SubExpression.class, 0); + expressionPrecedenceLookup.put(MulExpression.class, 1); + expressionPrecedenceLookup.put(DivExpression.class, 1); + + // unary + expressionPrecedenceLookup.put(AvgAggregateFunctionExpression.class, 2); + expressionPrecedenceLookup.put(MaxAggregateFunctionExpression.class, 2); + expressionPrecedenceLookup.put(MinAggregateFunctionExpression.class, 2); + expressionPrecedenceLookup.put(SumAggregateFunctionExpression.class, 2); + expressionPrecedenceLookup.put(ParenthesisConstraint.class, 2); + + expressionPrecedenceLookup.put(LiteralExpression.class, 2); + expressionPrecedenceLookup.put(NumberExpression.class, 2); + expressionPrecedenceLookup.put(StringExpression.class, 2); + } + + /** + * + * @param parent + * @param child + * @return + */ + private static boolean requiresBracketsInConstraint(Constraint parent, Constraint child) { + return constraintprecedenceLookup.get(parent.getClass()) >= constraintprecedenceLookup.get(child.getClass()); + } + + private static boolean requiresBracketsInExpression(Expression parent, Expression child) { + return expressionPrecedenceLookup.get(parent.getClass()) >= expressionPrecedenceLookup.get(child.getClass()); + } + + + public static String enforceConstraintBracketsIfNecessary(Constraint parent, Constraint child, boolean withSubmodels, String currentAlias) { + if (requiresBracketsInConstraint(parent, child)) { + return "(" + child.toString(withSubmodels, currentAlias) + ")"; + } else { + return child.toString(withSubmodels, currentAlias); + } + } + + public static String enforceExpressionBracketsIfNecessary(Expression parent, Expression child, boolean withSubmodels, String currentAlias) { + if (requiresBracketsInExpression(parent, child)) { + return "(" + child.toString(withSubmodels, currentAlias) + ")"; + } else { + return child.toString(withSubmodels, currentAlias); + } + } + + + +} diff --git a/src/main/java/de/vill/model/constraint/AndConstraint.java b/src/main/java/de/vill/model/constraint/AndConstraint.java index d3636ff..7587150 100644 --- a/src/main/java/de/vill/model/constraint/AndConstraint.java +++ b/src/main/java/de/vill/model/constraint/AndConstraint.java @@ -1,5 +1,6 @@ package de.vill.model.constraint; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import java.util.ArrayList; @@ -34,9 +35,9 @@ public void setRight(Constraint right){ @Override public String toString(boolean withSubmodels, String currentAlias) { - return left.toString(withSubmodels, currentAlias) + + return AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, left, withSubmodels, currentAlias) + " & " + - right.toString(withSubmodels, currentAlias); + AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, right, withSubmodels, currentAlias); } @Override diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index 23b7322..66c7a4a 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -1,5 +1,6 @@ package de.vill.model.constraint; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import java.util.ArrayList; @@ -26,11 +27,9 @@ public Constraint getRight() { @Override public String toString(boolean withSubmodels, String currentAlias) { - StringBuilder result = new StringBuilder(); - result.append(left.toString(withSubmodels, currentAlias)); - result.append(" <=> "); - result.append(right.toString(withSubmodels, currentAlias)); - return result.toString(); + return AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, left, withSubmodels, currentAlias) + + " <=> " + + AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, left, withSubmodels, currentAlias); } @Override diff --git a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java index a1cb8bb..854baf3 100644 --- a/src/main/java/de/vill/model/constraint/ImplicationConstraint.java +++ b/src/main/java/de/vill/model/constraint/ImplicationConstraint.java @@ -1,5 +1,6 @@ package de.vill.model.constraint; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import java.util.ArrayList; @@ -26,11 +27,9 @@ public Constraint getRight() { @Override public String toString(boolean withSubmodels, String currentAlias) { - StringBuilder result = new StringBuilder(); - result.append(left.toString(withSubmodels, currentAlias)); - result.append(" => "); - result.append(right.toString(withSubmodels, currentAlias)); - return result.toString(); + return AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, left, withSubmodels, currentAlias) + + " => " + + AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, right, withSubmodels, currentAlias); } @Override diff --git a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java index 63fa6a6..bb31d49 100644 --- a/src/main/java/de/vill/model/constraint/MultiOrConstraint.java +++ b/src/main/java/de/vill/model/constraint/MultiOrConstraint.java @@ -1,5 +1,6 @@ package de.vill.model.constraint; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import java.util.ArrayList; @@ -18,7 +19,7 @@ public MultiOrConstraint() { public String toString(boolean withSubmodels, String currentAlias) { StringBuilder result = new StringBuilder(); for (Constraint part : sub_parts) { - result.append(part.toString(withSubmodels, currentAlias)); + result.append(AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, part, withSubmodels, currentAlias)); result.append(" | "); } result.delete(result.length() -3, result.length()); diff --git a/src/main/java/de/vill/model/constraint/OrConstraint.java b/src/main/java/de/vill/model/constraint/OrConstraint.java index bcfd655..b29aba1 100644 --- a/src/main/java/de/vill/model/constraint/OrConstraint.java +++ b/src/main/java/de/vill/model/constraint/OrConstraint.java @@ -1,5 +1,6 @@ package de.vill.model.constraint; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import java.util.ArrayList; @@ -35,9 +36,9 @@ public void setRight(Constraint right){ @Override public String toString(boolean withSubmodels, String currentAlias) { - return left.toString(withSubmodels, currentAlias) + + return AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, left, withSubmodels, currentAlias) + " | " + - right.toString(withSubmodels, currentAlias); + AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, right, withSubmodels, currentAlias); } @Override diff --git a/src/main/java/de/vill/model/expression/AddExpression.java b/src/main/java/de/vill/model/expression/AddExpression.java index 709088e..5bcd88b 100644 --- a/src/main/java/de/vill/model/expression/AddExpression.java +++ b/src/main/java/de/vill/model/expression/AddExpression.java @@ -1,6 +1,7 @@ package de.vill.model.expression; import de.vill.model.Feature; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import de.vill.util.Constants; @@ -27,9 +28,9 @@ public Expression getRight() { @Override public String toString(boolean withSubmodels, String currentAlias) { - return left.toString(withSubmodels, currentAlias) + + return AutomaticBrackets.enforceExpressionBracketsIfNecessary(this, left, withSubmodels, currentAlias) + " + " + - right.toString(withSubmodels, currentAlias); + AutomaticBrackets.enforceExpressionBracketsIfNecessary(this, right, withSubmodels, currentAlias); } @Override diff --git a/src/main/java/de/vill/model/expression/DivExpression.java b/src/main/java/de/vill/model/expression/DivExpression.java index 7c6e2c8..0af62cb 100644 --- a/src/main/java/de/vill/model/expression/DivExpression.java +++ b/src/main/java/de/vill/model/expression/DivExpression.java @@ -1,6 +1,7 @@ package de.vill.model.expression; import de.vill.model.Feature; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import de.vill.util.Constants; @@ -27,9 +28,9 @@ public Expression getRight() { @Override public String toString(boolean withSubmodels, String currentAlias) { - return left.toString(withSubmodels, currentAlias) + + return AutomaticBrackets.enforceExpressionBracketsIfNecessary(this, left, withSubmodels, currentAlias) + " / " + - right.toString(withSubmodels, currentAlias); + AutomaticBrackets.enforceExpressionBracketsIfNecessary(this, right, withSubmodels, currentAlias); } @Override diff --git a/src/main/java/de/vill/model/expression/MulExpression.java b/src/main/java/de/vill/model/expression/MulExpression.java index f33359e..830b5b7 100644 --- a/src/main/java/de/vill/model/expression/MulExpression.java +++ b/src/main/java/de/vill/model/expression/MulExpression.java @@ -1,6 +1,7 @@ package de.vill.model.expression; import de.vill.model.Feature; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import de.vill.util.Constants; @@ -27,9 +28,9 @@ public Expression getRight() { @Override public String toString(boolean withSubmodels, String currentAlias) { - return left.toString(withSubmodels, currentAlias) + + return AutomaticBrackets.enforceExpressionBracketsIfNecessary(this, left, withSubmodels, currentAlias) + " * " + - right.toString(withSubmodels, currentAlias); + AutomaticBrackets.enforceExpressionBracketsIfNecessary(this, right, withSubmodels, currentAlias); } @Override diff --git a/src/main/java/de/vill/model/expression/SubExpression.java b/src/main/java/de/vill/model/expression/SubExpression.java index 53b81f4..448c755 100644 --- a/src/main/java/de/vill/model/expression/SubExpression.java +++ b/src/main/java/de/vill/model/expression/SubExpression.java @@ -1,6 +1,7 @@ package de.vill.model.expression; import de.vill.model.Feature; +import de.vill.model.building.AutomaticBrackets; import de.vill.model.building.VariableReference; import de.vill.util.Constants; @@ -25,9 +26,9 @@ public Expression getRight() { @Override public String toString(boolean withSubmodels, String currentAlias) { - return left.toString(withSubmodels, currentAlias) + + return AutomaticBrackets.enforceExpressionBracketsIfNecessary(this, left, withSubmodels, currentAlias) + " - " + - right.toString(withSubmodels, currentAlias); + AutomaticBrackets.enforceExpressionBracketsIfNecessary(this, right, withSubmodels, currentAlias); } @Override From b794dbc597c3e6e126bb37f1da8366f62e84f0e5 Mon Sep 17 00:00:00 2001 From: Chico Sundermann Date: Tue, 28 Jan 2025 21:07:02 +0100 Subject: [PATCH 57/60] Added unit tests for brackets; small fix --- .../constraint/EquivalenceConstraint.java | 2 +- src/test/java/de/vill/model/BracketsTest.java | 64 +++++++++++++++++++ 2 files changed, 65 insertions(+), 1 deletion(-) create mode 100644 src/test/java/de/vill/model/BracketsTest.java diff --git a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java index 66c7a4a..6a07fee 100644 --- a/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java +++ b/src/main/java/de/vill/model/constraint/EquivalenceConstraint.java @@ -29,7 +29,7 @@ public Constraint getRight() { public String toString(boolean withSubmodels, String currentAlias) { return AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, left, withSubmodels, currentAlias) + " <=> " + - AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, left, withSubmodels, currentAlias); + AutomaticBrackets.enforceConstraintBracketsIfNecessary(this, right, withSubmodels, currentAlias); } @Override diff --git a/src/test/java/de/vill/model/BracketsTest.java b/src/test/java/de/vill/model/BracketsTest.java new file mode 100644 index 0000000..2b06131 --- /dev/null +++ b/src/test/java/de/vill/model/BracketsTest.java @@ -0,0 +1,64 @@ +package de.vill.model; + +import de.vill.model.constraint.*; +import de.vill.model.expression.*; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +class BracketsTest { + + + private static LiteralConstraint A; + private static LiteralConstraint B; + + private static LiteralExpression C; + private static LiteralExpression D; + + @BeforeAll + static void setUpBeforeClass() throws Exception { + A = new LiteralConstraint(new Feature("A")); + B = new LiteralConstraint(new Feature("B")); + C = new LiteralExpression(new Feature("C")); + D = new LiteralExpression(new Feature("D")); + } + + @Test + void testSimpleBooleanLogic() { + Constraint simpleOr = new OrConstraint(A,B); + Constraint simpleAnd = new AndConstraint(A,B); + Constraint simpleImply = new ImplicationConstraint(A,B); + Constraint simpleEquivalence = new EquivalenceConstraint(A,B); + + // and-or + assert new AndConstraint(simpleOr, simpleOr).toString().equals("(A | B) & (A | B)"); + assert new OrConstraint(simpleAnd, simpleAnd).toString().equals("A & B | A & B"); + + // and-imply + assert new AndConstraint(simpleImply, simpleImply).toString().equals("(A => B) & (A => B)"); + assert new ImplicationConstraint(simpleAnd, simpleAnd).toString().equals("A & B => A & B"); + + // imply-equiv + assert new ImplicationConstraint(simpleEquivalence, simpleEquivalence).toString().equals("(A <=> B) => (A <=> B)"); + assert new EquivalenceConstraint(simpleImply, simpleImply).toString().equals("A => B <=> A => B"); + } + + @Test + void testSimpleExpressions() { + Expression simpleSub = new SubExpression(C,D); + Expression simpleAdd = new AddExpression(C,D); + Expression simpleMult = new MulExpression(C,D); + Expression simpleDiv = new DivExpression(C,D); + + // add-sub + assert new AddExpression(simpleSub, simpleSub).toString().equals("(C - D) + (C - D)"); + assert new SubExpression(simpleAdd, simpleAdd).toString().equals("(C + D) - (C + D)"); + + // add-mult + assert new AddExpression(simpleMult, simpleMult).toString().equals("C * D + C * D"); + assert new MulExpression(simpleAdd, simpleAdd).toString().equals("(C + D) * (C + D)"); + + // mult-div + assert new MulExpression(simpleDiv, simpleDiv).toString().equals("(C / D) * (C / D)"); + } + +} From 5d73f92d6631171c3f837d3a5ed5e42053dffadc Mon Sep 17 00:00:00 2001 From: Chico Sundermann Date: Thu, 27 Feb 2025 08:50:53 +0100 Subject: [PATCH 58/60] Several changes to simplify changing identifiers programatically with the fm builder --- src/main/java/de/vill/model/Attribute.java | 9 +++- .../java/de/vill/model/GlobalAttribute.java | 4 +- .../model/building/FeatureModelBuilder.java | 48 ++++++++++++++++++- 3 files changed, 57 insertions(+), 4 deletions(-) diff --git a/src/main/java/de/vill/model/Attribute.java b/src/main/java/de/vill/model/Attribute.java index 080a4de..29ad6db 100644 --- a/src/main/java/de/vill/model/Attribute.java +++ b/src/main/java/de/vill/model/Attribute.java @@ -20,8 +20,8 @@ public class Attribute implements VariableReference { private int line; - private final String name; - private final T value; + private String name; + private T value; private Feature feature; /** @@ -53,6 +53,8 @@ public T getValue() { return value; } + public void setValue(T value) { this.value = value; } + /** * Returns the name of the attribute. * @@ -62,6 +64,9 @@ public String getName() { return name; } + public void setName(String name) { this.name = name; } + + /** * Returns the type of the attribute * @return Name of the attribute (never null) diff --git a/src/main/java/de/vill/model/GlobalAttribute.java b/src/main/java/de/vill/model/GlobalAttribute.java index 44bd01b..b984cbf 100644 --- a/src/main/java/de/vill/model/GlobalAttribute.java +++ b/src/main/java/de/vill/model/GlobalAttribute.java @@ -34,7 +34,7 @@ public static AttributeType fromString(String name) { } } - private final String identifier; + private String identifier; private AttributeType type; private final Set featuresContainingAttribute; @@ -55,6 +55,8 @@ public GlobalAttribute(String identifier, AttributeType type) { featuresContainingAttribute = new HashSet<>(); } + public void renameGlobalAttribute(String newIdentifier) { this.identifier = newIdentifier;} + public void addFeature(Feature feature) { featuresContainingAttribute.add(feature); } diff --git a/src/main/java/de/vill/model/building/FeatureModelBuilder.java b/src/main/java/de/vill/model/building/FeatureModelBuilder.java index 19f178e..bb998a6 100644 --- a/src/main/java/de/vill/model/building/FeatureModelBuilder.java +++ b/src/main/java/de/vill/model/building/FeatureModelBuilder.java @@ -3,7 +3,10 @@ import de.vill.exception.ParseError; import de.vill.model.*; import de.vill.model.constraint.Constraint; +import de.vill.model.constraint.ExpressionConstraint; import de.vill.model.constraint.LiteralConstraint; +import de.vill.model.expression.AggregateFunctionExpression; +import de.vill.model.expression.Expression; import java.util.List; import java.util.Map; @@ -102,7 +105,7 @@ public void addAttribute(Feature feature, Attribute attribute) { */ public boolean renameFeature(String oldName, String newName) { Map featureMap = fmInConstruction.getFeatureMap(); - if (featureMap.containsKey(oldName)) { + if (!featureMap.containsKey(oldName)) { return false; } Feature featureToUpdate = featureMap.get(oldName); @@ -116,6 +119,49 @@ public boolean renameFeature(String oldName, String newName) { return true; } + public void renameAttribute(Attribute attribute, String newName) { + String oldName = attribute.getName(); + attribute.setName(newName); + attribute.getFeature().getAttributes().remove(oldName); + attribute.getFeature().getAttributes().put(newName, attribute); + } + + public void renameAttributeGlobally(String oldName, String newName) { + for (Feature feature : fmInConstruction.getFeatureMap().values()) { + if (feature.getAttributes().containsKey(oldName)) { + Attribute attribute = feature.getAttributes().get(oldName); + renameAttribute(attribute, newName); + } + } + for (Constraint constraint : fmInConstruction.getConstraints()) { + crawlConstraintsToRenameGlobalAttribute(constraint, oldName, newName); + } + } + private void crawlConstraintsToRenameGlobalAttribute(Constraint constraint, String attributeName, String replace) { + if (constraint instanceof ExpressionConstraint) { + for (Expression exp : ((ExpressionConstraint) constraint).getExpressionSubParts()) { + crawlExpressionsToRenameGlobalAttribute(exp, attributeName, replace); + } + } else { + for (Constraint child : constraint.getConstraintSubParts()) { + crawlConstraintsToRenameGlobalAttribute(child, attributeName, replace); + } + } + } + + private void crawlExpressionsToRenameGlobalAttribute(Expression expression, String attributeName, String replace) { + if (expression instanceof AggregateFunctionExpression) { + AggregateFunctionExpression aggregateFunctionExpression = (AggregateFunctionExpression) expression; + if (aggregateFunctionExpression.getAttribute().getIdentifier().equals(attributeName)) { + aggregateFunctionExpression.getAttribute().renameGlobalAttribute(replace); + }; + } else { + for (Expression exp : expression.getExpressionSubParts()) { + crawlExpressionsToRenameGlobalAttribute(exp, attributeName, replace); + } + } + } + public void addConstraint(Constraint constraint) { fmInConstruction.getOwnConstraints().add(0,constraint); } From 50941df874793f41723a69dc0b42688f488a7116 Mon Sep 17 00:00:00 2001 From: Chico Sundermann Date: Mon, 1 Sep 2025 16:36:16 +0200 Subject: [PATCH 59/60] Resolved issues following merge --- .../vill/model/building/AutomaticBrackets.java | 2 +- .../expression/AggregateFunctionExpression.java | 16 ++++++++++------ .../AvgAggregateFunctionExpression.java | 5 +++++ .../MaxAggregateFunctionExpression.java | 5 +++++ .../MinAggregateFunctionExpression.java | 5 +++++ .../SumAggregateFunctionExpression.java | 4 ++++ 6 files changed, 30 insertions(+), 7 deletions(-) diff --git a/src/main/java/de/vill/model/building/AutomaticBrackets.java b/src/main/java/de/vill/model/building/AutomaticBrackets.java index f71b272..2964b30 100644 --- a/src/main/java/de/vill/model/building/AutomaticBrackets.java +++ b/src/main/java/de/vill/model/building/AutomaticBrackets.java @@ -54,7 +54,7 @@ private AutomaticBrackets() {} expressionPrecedenceLookup.put(MaxAggregateFunctionExpression.class, 2); expressionPrecedenceLookup.put(MinAggregateFunctionExpression.class, 2); expressionPrecedenceLookup.put(SumAggregateFunctionExpression.class, 2); - expressionPrecedenceLookup.put(ParenthesisConstraint.class, 2); + expressionPrecedenceLookup.put(ParenthesisExpression.class, 2); expressionPrecedenceLookup.put(LiteralExpression.class, 2); expressionPrecedenceLookup.put(NumberExpression.class, 2); diff --git a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java index dbb2208..b60efdf 100644 --- a/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/AggregateFunctionExpression.java @@ -11,12 +11,21 @@ import java.util.Objects; import java.util.Set; -import static de.vill.util.Util.addNecessaryQuotes; public abstract class AggregateFunctionExpression extends Expression { protected GlobalAttribute attribute; protected Feature rootFeature; + + public AggregateFunctionExpression(GlobalAttribute attribute) { + this.attribute = attribute; + } + + public AggregateFunctionExpression(GlobalAttribute attribute, Feature rootFeature) { + this(attribute); + this.rootFeature = rootFeature; + } + @Override public String toString(boolean withSubmodels, String currentAlias) { return toString(withSubmodels, "aggregateFunction", currentAlias); @@ -98,9 +107,4 @@ public boolean equals(Object obj) { public List getReferences() { return List.of(attribute); } - - @Override - public Expression clone(){ - return new AggregateFunctionExpression(attribute, rootFeature); - } } diff --git a/src/main/java/de/vill/model/expression/AvgAggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/AvgAggregateFunctionExpression.java index d3bdb2a..68e04d1 100644 --- a/src/main/java/de/vill/model/expression/AvgAggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/AvgAggregateFunctionExpression.java @@ -51,4 +51,9 @@ public List getExpressionSubParts() { public String getReturnType() { return Constants.NUMBER; } + + @Override + public Expression clone() { + return new AvgAggregateFunctionExpression(attribute, rootFeature); + } } diff --git a/src/main/java/de/vill/model/expression/MaxAggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/MaxAggregateFunctionExpression.java index ccd0766..4bd9cb5 100644 --- a/src/main/java/de/vill/model/expression/MaxAggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/MaxAggregateFunctionExpression.java @@ -51,4 +51,9 @@ public String getReturnType() { public List getExpressionSubParts() { return Arrays.asList(); } + + @Override + public Expression clone() { + return new MaxAggregateFunctionExpression(attribute, rootFeature); + } } diff --git a/src/main/java/de/vill/model/expression/MinAggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/MinAggregateFunctionExpression.java index c7d1421..b61ec32 100644 --- a/src/main/java/de/vill/model/expression/MinAggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/MinAggregateFunctionExpression.java @@ -52,4 +52,9 @@ public String getReturnType() { public List getExpressionSubParts() { return Arrays.asList(); } + + @Override + public Expression clone() { + return new MinAggregateFunctionExpression(attribute, rootFeature); + } } diff --git a/src/main/java/de/vill/model/expression/SumAggregateFunctionExpression.java b/src/main/java/de/vill/model/expression/SumAggregateFunctionExpression.java index 4e1863a..cca56e3 100644 --- a/src/main/java/de/vill/model/expression/SumAggregateFunctionExpression.java +++ b/src/main/java/de/vill/model/expression/SumAggregateFunctionExpression.java @@ -49,4 +49,8 @@ public List getExpressionSubParts() { public String getReturnType() { return Constants.NUMBER; } + @Override + public Expression clone() { + return new SumAggregateFunctionExpression(attribute, rootFeature); + } } From 5edec1fcfc80ff08ebb805b6f32c37b28f2b676f Mon Sep 17 00:00:00 2001 From: Chico Sundermann Date: Wed, 3 Sep 2025 10:28:35 +0200 Subject: [PATCH 60/60] misc: updated changes according to Kevin's review --- .../conversion/ConvertFeatureCardinality.java | 42 ---------- .../conversion/ConvertGroupCardinality.java | 14 ---- .../de/vill/conversion/ConvertSMTLevel.java | 14 ---- .../model/building/AutomaticBrackets.java | 77 ++++++++++++------- 4 files changed, 49 insertions(+), 98 deletions(-) diff --git a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java index 9dbcdb0..d89d062 100644 --- a/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java +++ b/src/main/java/de/vill/conversion/ConvertFeatureCardinality.java @@ -89,56 +89,14 @@ private void removeFeatureCardinality(Feature feature, FeatureModel featureModel } } } -/* -additional constraint with all cloned versions ored - Set allFeatureNamesInSubTree = new HashSet<>(); - getAllSubFeatureNamesRecursively(feature, allFeatureNamesInSubTree); - for (Constraint constraint : constraintsToClone) { - Constraint newConstraint = constraint.clone(); - orAdaptedConstraint(newConstraint, allFeatureNamesInSubTree, min, max, featureModel); - featureModel.getOwnConstraints().add(newConstraint); - } - - */ - feature.getChildren().removeAll(feature.getChildren()); feature.getChildren().add(newChildren); newChildren.setParentFeature(feature); } - private void orAdaptedConstraint(Constraint constraint, Set featuresToReplace, int min, int max, FeatureModel featureModel) { - for (Constraint subPart : constraint.getConstraintSubParts()) { - if (subPart instanceof LiteralConstraint) { - String toReplace = ((LiteralConstraint) subPart).getReference().getIdentifier(); - if (featuresToReplace.contains(toReplace)) { - Feature f = featureModel.getFeatureMap().get(toReplace + "-" + (min == 0 ? 1 : min) + "-1"); - Constraint newOr = new LiteralConstraint(f); - for (int i = min + 1; i <= max; i++) { - for (int j = 1; j <= i; j++) { - newOr = new OrConstraint(newOr, new LiteralConstraint(featureModel.getFeatureMap().get(toReplace + "-" + i + "-" + j))); - } - } - constraint.replaceConstraintSubPart(subPart, new ParenthesisConstraint(newOr)); - } - } else { - orAdaptedConstraint(subPart, featuresToReplace, min, max, featureModel); - } - } - } - - private void getAllSubFeatureNamesRecursively(Feature feature, Set names) { - names.add(feature.getFeatureName()); - for (Group child : feature.getChildren()) { - for (Feature childFeature : child.getFeatures()) { - getAllSubFeatureNamesRecursively(childFeature, names); - } - } - } - private void addPrefixToNamesRecursively(Feature feature, String prefix, FeatureModel featureModel) { feature.setFeatureName(feature.getFeatureName() + prefix); - var attributes = feature.getAttributes(); featureModel.getFeatureMap().put(feature.getFeatureName(), feature); if (!feature.isSubmodelRoot()) { for (Group group : feature.getChildren()) { diff --git a/src/main/java/de/vill/conversion/ConvertGroupCardinality.java b/src/main/java/de/vill/conversion/ConvertGroupCardinality.java index c5e88b1..89f051e 100644 --- a/src/main/java/de/vill/conversion/ConvertGroupCardinality.java +++ b/src/main/java/de/vill/conversion/ConvertGroupCardinality.java @@ -85,20 +85,6 @@ private Constraint createDisjunction(Set constraints) { for (Constraint constraint : constraints) { orConstraint.add_sub_part(constraint); } - /* - Constraint orConstraint; - if (constraints.size() == 1) { - Constraint constraint = constraints.iterator().next(); - constraints.remove(constraint); - orConstraint = constraint; - } else { - Constraint constraint = constraints.iterator().next(); - constraints.remove(constraint); - orConstraint = new OrConstraint(constraint, createDisjunction(constraints)); - } - - */ - return orConstraint; } } diff --git a/src/main/java/de/vill/conversion/ConvertSMTLevel.java b/src/main/java/de/vill/conversion/ConvertSMTLevel.java index 16955c1..b45b99f 100644 --- a/src/main/java/de/vill/conversion/ConvertSMTLevel.java +++ b/src/main/java/de/vill/conversion/ConvertSMTLevel.java @@ -140,20 +140,6 @@ private Constraint createDisjunction(Set constraints) { for (Constraint constraint : constraints) { orConstraint.add_sub_part(constraint); } - /* - Constraint orConstraint; - if (constraints.size() == 1) { - Constraint constraint = constraints.iterator().next(); - constraints.remove(constraint); - orConstraint = constraint; - } else { - Constraint constraint = constraints.iterator().next(); - constraints.remove(constraint); - orConstraint = new OrConstraint(constraint, createDisjunction(constraints)); - } - - */ - return orConstraint; } diff --git a/src/main/java/de/vill/model/building/AutomaticBrackets.java b/src/main/java/de/vill/model/building/AutomaticBrackets.java index 2964b30..fa9a80e 100644 --- a/src/main/java/de/vill/model/building/AutomaticBrackets.java +++ b/src/main/java/de/vill/model/building/AutomaticBrackets.java @@ -20,45 +20,58 @@ private AutomaticBrackets() {} static Map expressionPrecedenceLookup; + public final static int IFF_PRECEDENCE = 0; + public final static int IMPLY_PRECEDENCE = 1; + public final static int OR_PRECEDENCE = 2; + public final static int AND_PRECEDENCE = 3; + public final static int GEQ_LEQ_PRECEDENCE = 4; + public final static int EQUATION_PRECEDENCE = 5; + public final static int CONSTRAINT_UNARY_PRECEDENCE = 6; + + public final static int ADD_SUB_PRECEDENCE = 0; + public final static int MULT_DIV_PRECEDENCE = 1; + public final static int UNARY_EXPRESSION_PRECEDENCE = 2; + + static { constraintprecedenceLookup = new HashMap<>(); // n-ary - constraintprecedenceLookup.put(EquivalenceConstraint.class, 0); - constraintprecedenceLookup.put(ImplicationConstraint.class, 1); - constraintprecedenceLookup.put(OrConstraint.class, 2); - constraintprecedenceLookup.put(MultiOrConstraint.class, 2); - constraintprecedenceLookup.put(AndConstraint.class, 3); - constraintprecedenceLookup.put(GreaterEquationConstraint.class, 4); - constraintprecedenceLookup.put(LowerEquationConstraint.class, 4); - constraintprecedenceLookup.put(GreaterEqualsEquationConstraint.class, 4); - constraintprecedenceLookup.put(LowerEqualsEquationConstraint.class, 4); - constraintprecedenceLookup.put(NotEqualsEquationConstraint.class, 5); - constraintprecedenceLookup.put(EqualEquationConstraint.class, 5); + constraintprecedenceLookup.put(EquivalenceConstraint.class, IFF_PRECEDENCE); + constraintprecedenceLookup.put(ImplicationConstraint.class, IMPLY_PRECEDENCE); + constraintprecedenceLookup.put(OrConstraint.class, OR_PRECEDENCE); + constraintprecedenceLookup.put(MultiOrConstraint.class, OR_PRECEDENCE); + constraintprecedenceLookup.put(AndConstraint.class, AND_PRECEDENCE); + constraintprecedenceLookup.put(GreaterEquationConstraint.class, GEQ_LEQ_PRECEDENCE); + constraintprecedenceLookup.put(LowerEquationConstraint.class, GEQ_LEQ_PRECEDENCE); + constraintprecedenceLookup.put(GreaterEqualsEquationConstraint.class, GEQ_LEQ_PRECEDENCE); + constraintprecedenceLookup.put(LowerEqualsEquationConstraint.class, GEQ_LEQ_PRECEDENCE); + constraintprecedenceLookup.put(NotEqualsEquationConstraint.class, EQUATION_PRECEDENCE); + constraintprecedenceLookup.put(EqualEquationConstraint.class, EQUATION_PRECEDENCE); // Unary - constraintprecedenceLookup.put(LiteralConstraint.class, 6); - constraintprecedenceLookup.put(NotConstraint.class, 6); - constraintprecedenceLookup.put(ParenthesisConstraint.class, 6); + constraintprecedenceLookup.put(LiteralConstraint.class, CONSTRAINT_UNARY_PRECEDENCE); + constraintprecedenceLookup.put(NotConstraint.class, CONSTRAINT_UNARY_PRECEDENCE); + constraintprecedenceLookup.put(ParenthesisConstraint.class, CONSTRAINT_UNARY_PRECEDENCE); expressionPrecedenceLookup = new HashMap<>(); // n-ary - expressionPrecedenceLookup.put(AddExpression.class, 0); - expressionPrecedenceLookup.put(SubExpression.class, 0); - expressionPrecedenceLookup.put(MulExpression.class, 1); - expressionPrecedenceLookup.put(DivExpression.class, 1); + expressionPrecedenceLookup.put(AddExpression.class, ADD_SUB_PRECEDENCE); + expressionPrecedenceLookup.put(SubExpression.class, ADD_SUB_PRECEDENCE); + expressionPrecedenceLookup.put(MulExpression.class, MULT_DIV_PRECEDENCE); + expressionPrecedenceLookup.put(DivExpression.class, MULT_DIV_PRECEDENCE); // unary - expressionPrecedenceLookup.put(AvgAggregateFunctionExpression.class, 2); - expressionPrecedenceLookup.put(MaxAggregateFunctionExpression.class, 2); - expressionPrecedenceLookup.put(MinAggregateFunctionExpression.class, 2); - expressionPrecedenceLookup.put(SumAggregateFunctionExpression.class, 2); - expressionPrecedenceLookup.put(ParenthesisExpression.class, 2); - - expressionPrecedenceLookup.put(LiteralExpression.class, 2); - expressionPrecedenceLookup.put(NumberExpression.class, 2); - expressionPrecedenceLookup.put(StringExpression.class, 2); + expressionPrecedenceLookup.put(AvgAggregateFunctionExpression.class, UNARY_EXPRESSION_PRECEDENCE); + expressionPrecedenceLookup.put(MaxAggregateFunctionExpression.class, UNARY_EXPRESSION_PRECEDENCE); + expressionPrecedenceLookup.put(MinAggregateFunctionExpression.class, UNARY_EXPRESSION_PRECEDENCE); + expressionPrecedenceLookup.put(SumAggregateFunctionExpression.class, UNARY_EXPRESSION_PRECEDENCE); + expressionPrecedenceLookup.put(ParenthesisExpression.class, UNARY_EXPRESSION_PRECEDENCE); + + expressionPrecedenceLookup.put(LiteralExpression.class, UNARY_EXPRESSION_PRECEDENCE); + expressionPrecedenceLookup.put(NumberExpression.class, UNARY_EXPRESSION_PRECEDENCE); + expressionPrecedenceLookup.put(StringExpression.class, UNARY_EXPRESSION_PRECEDENCE); } /** @@ -75,7 +88,15 @@ private static boolean requiresBracketsInExpression(Expression parent, Expressio return expressionPrecedenceLookup.get(parent.getClass()) >= expressionPrecedenceLookup.get(child.getClass()); } - + /** + * Method can be used so that the printed versions of constraints are semantically equivalent to the internal object representation + * @see de.vill.model.building.AutomaticBrackets for the precendences + * @param parent + * @param child + * @param withSubmodels Consider imported submodels + * @param currentAlias Check alias of submodel at hand + * @return + */ public static String enforceConstraintBracketsIfNecessary(Constraint parent, Constraint child, boolean withSubmodels, String currentAlias) { if (requiresBracketsInConstraint(parent, child)) { return "(" + child.toString(withSubmodels, currentAlias) + ")";