diff --git a/src/main/java/de/ids_mannheim/korap/query/DistanceConstraint.java b/src/main/java/de/ids_mannheim/korap/query/DistanceConstraint.java
index 29e191a..9a92307 100644
--- a/src/main/java/de/ids_mannheim/korap/query/DistanceConstraint.java
+++ b/src/main/java/de/ids_mannheim/korap/query/DistanceConstraint.java
@@ -1,6 +1,7 @@
 package de.ids_mannheim.korap.query;
 
-/**	Create a distance constraint for multiple distance query.
+/**	Specify constraints of distance in SpanDistanceQueries or 
+ * 	SpanMultipleDistanceQueries
  * 	 
  * 	@author margaretha
  * */
@@ -10,23 +11,43 @@
 	private String unit;
 	private SpanElementQuery elementQuery;
 	private boolean exclusion;
+	private boolean isOrdered;
 	
-	public DistanceConstraint(int min, int max, boolean exclusion) {
+	public DistanceConstraint(int min, int max, boolean isOrdered, boolean exclusion) {
 		this.unit = "w";
 		this.minDistance = min;
 		this.maxDistance = max;
-		this.exclusion = exclusion;
+		this.isOrdered = isOrdered;
+		this.exclusion = exclusion;		
 	}
 	
-	public DistanceConstraint(SpanElementQuery elementQuery, int min, int max, 
-			boolean exclusion) {
+	public DistanceConstraint(SpanElementQuery elementQuery, int min, int max, boolean 
+			isOrdered, boolean exclusion) {
 		this.unit = elementQuery.getElementStr();
 		this.minDistance = min;
 		this.maxDistance = max;
-		this.exclusion = exclusion;		
-		this.elementQuery = elementQuery;		
+		this.isOrdered = isOrdered;
+		this.exclusion = exclusion;
+		this.elementQuery = elementQuery;
 	}
 	
+	
+//	public DistanceConstraint(int min, int max, boolean exclusion) {
+//		this.unit = "w";
+//		this.minDistance = min;
+//		this.maxDistance = max;
+//		this.exclusion = exclusion;
+//	}
+//	
+//	public DistanceConstraint(SpanElementQuery elementQuery, int min, int max, 
+//			boolean exclusion) {
+//		this.unit = elementQuery.getElementStr();
+//		this.minDistance = min;
+//		this.maxDistance = max;
+//		this.exclusion = exclusion;		
+//		this.elementQuery = elementQuery;		
+//	}
+	
 	public int getMinDistance() {
 		return minDistance;
 	}
@@ -59,4 +80,12 @@
 	public void setExclusion(boolean exclusion) {
 		this.exclusion = exclusion;
 	}
+
+	public boolean isOrdered() {
+		return isOrdered;
+	}
+
+	public void setOrdered(boolean isOrdered) {
+		this.isOrdered = isOrdered;
+	}
 }
diff --git a/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java b/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java
index 7ce869a..6b01fdb 100644
--- a/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java
+++ b/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java
@@ -34,32 +34,50 @@
 	private SpanElementQuery elementQuery; // element distance unit
 	private String distanceUnit;
 	private String spanName;
+	private DistanceConstraint constraint;
 
 	public SpanDistanceQuery(SpanQuery firstClause, SpanQuery secondClause, 
-			int minDistance, int maxDistance, boolean isOrdered, 
-			boolean collectPayloads) {		
-		super(firstClause, secondClause, collectPayloads); 
-		init(minDistance, maxDistance, isOrdered);
-		distanceUnit = "w";
-		spanName = "spanDistance";
-	}
-	
-	public SpanDistanceQuery(SpanElementQuery elementQuery, SpanQuery firstClause, 
-			SpanQuery secondClause, int minDistance, int maxDistance, 
-			boolean isOrdered, boolean collectPayloads) {
+			DistanceConstraint constraint, boolean collectPayloads) {
 		super(firstClause, secondClause, collectPayloads);
-    	init(minDistance, maxDistance, isOrdered);
-		this.elementQuery = elementQuery;
-		distanceUnit = elementQuery.getElementStr();
-		spanName = "spanElementDistance";
+		this.constraint = constraint;
+		this.minDistance = constraint.getMinDistance();
+		this.maxDistance = constraint.getMaxDistance();
+		this.isOrdered = constraint.isOrdered();
+		this.exclusion = constraint.isExclusion();
+		this.distanceUnit = constraint.getUnit();
+		
+		if (constraint.getElementQuery() != null){
+			spanName = "spanElementDistance";
+			this.elementQuery = constraint.getElementQuery();
+		}
+		else { spanName = "spanDistance"; }
 	}
 	
-	private void init(int minDistance, int maxDistance,boolean isOrdered){
-		this.minDistance = minDistance;
-		this.maxDistance = maxDistance;
-		this.isOrdered = isOrdered;
-		this.exclusion = false;
-	}
+//	public SpanDistanceQuery(SpanQuery firstClause, SpanQuery secondClause, 
+//			int minDistance, int maxDistance, boolean isOrdered, 
+//			boolean collectPayloads) {		
+//		super(firstClause, secondClause, collectPayloads); 
+//		init(minDistance, maxDistance, isOrdered);
+//		distanceUnit = "w";
+//		spanName = "spanDistance";
+//	}
+//	
+//	public SpanDistanceQuery(SpanElementQuery elementQuery, SpanQuery firstClause, 
+//			SpanQuery secondClause, int minDistance, int maxDistance, 
+//			boolean isOrdered, boolean collectPayloads) {
+//		super(firstClause, secondClause, collectPayloads);
+//    	init(minDistance, maxDistance, isOrdered);
+//		this.elementQuery = elementQuery;
+//		distanceUnit = elementQuery.getElementStr();
+//		spanName = "spanElementDistance";
+//	}
+//	
+//	private void init(int minDistance, int maxDistance,boolean isOrdered){
+//		this.minDistance = minDistance;
+//		this.maxDistance = maxDistance;
+//		this.isOrdered = isOrdered;
+//		this.exclusion = false;
+//	}
 	
 	@Override
 	public String toString(String field) {
@@ -84,20 +102,17 @@
     }
 	
 	@Override
-	public SpanDistanceQuery clone() {
+	public SpanDistanceQuery clone() {		
 		SpanDistanceQuery spanDistanceQuery = new SpanDistanceQuery(
 		    (SpanQuery) firstClause.clone(),
 		    (SpanQuery) secondClause.clone(),
-		    this.minDistance,
-		    this.maxDistance,
-		    this.isOrdered,
+		    this.constraint,
 		    this.collectPayloads
         );
 				
 		if (this.elementQuery != null) {
 			spanDistanceQuery.setElementQuery(this.elementQuery);
 		}
-		spanDistanceQuery.setExclusion(this.exclusion);
 		spanDistanceQuery.setBoost(getBoost());
 		return spanDistanceQuery;	
 	}
diff --git a/src/main/java/de/ids_mannheim/korap/query/SpanMultipleDistanceQuery.java b/src/main/java/de/ids_mannheim/korap/query/SpanMultipleDistanceQuery.java
index 473e9c6..43cff3f 100644
--- a/src/main/java/de/ids_mannheim/korap/query/SpanMultipleDistanceQuery.java
+++ b/src/main/java/de/ids_mannheim/korap/query/SpanMultipleDistanceQuery.java
@@ -72,7 +72,7 @@
 			sb.append(":");
 			sb.append(c.getMaxDistance());
 			sb.append("], ");		
-			sb.append(isOrdered ? "ordered, " : "notOrdered, ");
+			sb.append(c.isOrdered() ? "ordered, " : "notOrdered, ");
 			sb.append(c.isExclusion() ? "excluded)]" : "notExcluded)");			
 			if (i < size-1) sb.append(", ");
 		}		
@@ -89,18 +89,17 @@
 	public Spans getSpans(AtomicReaderContext context, Bits acceptDocs,
 			Map<Term, TermContext> termContexts) throws IOException {			
 		
-		DistanceConstraint c;		
 		SpanDistanceQuery sdq,sdq2;		
 		Spans ds,ds2;
 		MultipleDistanceSpans mds = null;
 		boolean exclusion;
-		
-		c = constraints.get(0);
-		sdq = createSpanDistanceQuery(c);
+				
+		sdq = new SpanDistanceQuery(firstClause, secondClause, constraints.get(0), collectPayloads);
 		ds = sdq.getSpans(context, acceptDocs, termContexts);
 				
 		for (int i=1; i< constraints.size(); i++){
-			sdq2 = createSpanDistanceQuery(constraints.get(i));
+			sdq2 = new SpanDistanceQuery(firstClause, secondClause, constraints.get(i), 
+					collectPayloads);
 			ds2 = sdq2.getSpans(context, acceptDocs, termContexts);			
 			
 			exclusion = sdq.isExclusion() && sdq2.isExclusion();
@@ -110,26 +109,7 @@
 		}
 		
 		return mds;
-	}
-	
-	/** Create a SpanDistanceQuery based on the given constraint.
-	 * 	@return a SpanDistanceQuery 
-	 * */
-	private SpanDistanceQuery createSpanDistanceQuery(DistanceConstraint c) {		
-		SpanDistanceQuery sdq;		
-		if (c.getUnit().equals("w")){
-			sdq = new SpanDistanceQuery(firstClause, secondClause,
-					c.getMinDistance(), c.getMaxDistance(),isOrdered, 
-					collectPayloads);		
-		}
-		else {
-			sdq = new SpanDistanceQuery(c.getElementQuery(), firstClause, 
-					secondClause, c.getMinDistance(), c.getMaxDistance(),
-					isOrdered, collectPayloads);
-		}
-		sdq.setExclusion(c.isExclusion());
-		return sdq;
-	}
+	}	
 
 	public List<DistanceConstraint> getConstraints() {
 		return constraints;
diff --git a/src/main/java/de/ids_mannheim/korap/query/SpanQuantifierQuery.java b/src/main/java/de/ids_mannheim/korap/query/SpanRepetitionQuery.java
similarity index 82%
rename from src/main/java/de/ids_mannheim/korap/query/SpanQuantifierQuery.java
rename to src/main/java/de/ids_mannheim/korap/query/SpanRepetitionQuery.java
index 85b881b..e25e5fe 100644
--- a/src/main/java/de/ids_mannheim/korap/query/SpanQuantifierQuery.java
+++ b/src/main/java/de/ids_mannheim/korap/query/SpanRepetitionQuery.java
@@ -11,13 +11,13 @@
 import org.apache.lucene.util.Bits;
 import org.apache.lucene.util.ToStringUtils;
 
-import de.ids_mannheim.korap.query.spans.QuantifierSpans;
+import de.ids_mannheim.korap.query.spans.RepetitionSpans;
 
-public class SpanQuantifierQuery extends SimpleSpanQuery{
+public class SpanRepetitionQuery extends SimpleSpanQuery{
 	
 	private int min, max;
 	
-	public SpanQuantifierQuery(SpanQuery sq, int min, int max,
+	public SpanRepetitionQuery(SpanQuery sq, int min, int max,
 			boolean collectPayloads) {
 		super(sq, collectPayloads);
 		this.min = min;
@@ -26,7 +26,7 @@
 
 	@Override
 	public SimpleSpanQuery clone() {
-		SpanQuantifierQuery sq = new SpanQuantifierQuery(
+		SpanRepetitionQuery sq = new SpanRepetitionQuery(
 				(SpanQuery) this.firstClause.clone(), 
 				this.min, 
 				this.max, 
@@ -38,7 +38,7 @@
 	@Override
 	public Spans getSpans(AtomicReaderContext context, Bits acceptDocs,
 			Map<Term, TermContext> termContexts) throws IOException {
-		return new QuantifierSpans(this, context, acceptDocs, termContexts);
+		return new RepetitionSpans(this, context, acceptDocs, termContexts);
 	}
 
 	@Override
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/QuantifierSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/RepetitionSpans.java
similarity index 92%
rename from src/main/java/de/ids_mannheim/korap/query/spans/QuantifierSpans.java
rename to src/main/java/de/ids_mannheim/korap/query/spans/RepetitionSpans.java
index 8c99ac0..923debc 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/QuantifierSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/RepetitionSpans.java
@@ -13,16 +13,16 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import de.ids_mannheim.korap.query.SpanQuantifierQuery;
+import de.ids_mannheim.korap.query.SpanRepetitionQuery;
 
-public class QuantifierSpans extends SimpleSpans{
+public class RepetitionSpans extends SimpleSpans{
 	
 	private int min,max;
 	private long matchCost;
 	private List<CandidateSpan> matchList;
-	private Logger log = LoggerFactory.getLogger(QuantifierSpans.class);
+	private Logger log = LoggerFactory.getLogger(RepetitionSpans.class);
 	
-	public QuantifierSpans(SpanQuantifierQuery query,
+	public RepetitionSpans(SpanRepetitionQuery query,
 			AtomicReaderContext context, Bits acceptDocs,
 			Map<Term, TermContext> termContexts) 
 			throws IOException {
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedElementDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedElementDistanceSpans.java
index b9ed42c..a0c4474 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedElementDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedElementDistanceSpans.java
@@ -197,7 +197,7 @@
 			}
 			 
 			if (minDistance <= actualDistance && actualDistance <= maxDistance)
-				matches.add(createMatchCandidate(target, cs, false));			
+				matches.add(createMatchCandidate(target, cs, false));
 		}		
 		return matches;
 	}
diff --git a/src/main/java/de/ids_mannheim/korap/query/wrap/SpanSequenceQueryWrapper.java b/src/main/java/de/ids_mannheim/korap/query/wrap/SpanSequenceQueryWrapper.java
index abf2ae4..5e1c91e 100644
--- a/src/main/java/de/ids_mannheim/korap/query/wrap/SpanSequenceQueryWrapper.java
+++ b/src/main/java/de/ids_mannheim/korap/query/wrap/SpanSequenceQueryWrapper.java
@@ -96,7 +96,7 @@
     public SpanSequenceQueryWrapper withConstraint (int min, int max, boolean exclusion) {
 	if (this.constraints == null)
 	    this.constraints = new ArrayList<DistanceConstraint>(1);
-	this.constraints.add(new DistanceConstraint(min, max, exclusion));
+	this.constraints.add(new DistanceConstraint(min, max, isInOrder, exclusion));
 	return this;
     };
 
@@ -111,11 +111,11 @@
 	if (this.constraints == null)
 	    this.constraints = new ArrayList<DistanceConstraint>(1);
 	if (unit.equals("w"))
-	    this.constraints.add(new DistanceConstraint(min, max, exclusion));
+	    this.constraints.add(new DistanceConstraint(min, max, isInOrder, exclusion));
 	else
 	    this.constraints.add(
 		 new DistanceConstraint(
-                     new SpanElementQuery(this.field, unit), min, max, exclusion)
+                     new SpanElementQuery(this.field, unit), min, max, isInOrder, exclusion)
 	    );
 	return this;
     };
@@ -150,15 +150,11 @@
 	    if (!constraint.getUnit().equals("w")) {
 		for (int i = 1; i < this.segments.size(); i++) {
 		    SpanDistanceQuery sdquery = new SpanDistanceQuery(
-		        new SpanElementQuery(this.field, constraint.getUnit()),
-	                query,
-			this.segments.get(i),
-			constraint.getMinDistance(),
-			constraint.getMaxDistance(),
-			this.isInOrder(),
-			true
+			    query,
+				this.segments.get(i),
+				constraint,
+				true
 		    );
-		    sdquery.setExclusion(constraint.isExclusion());
 		    query = (SpanQuery) sdquery;
 		};
 	    }
@@ -169,12 +165,9 @@
 		    SpanDistanceQuery sdquery = new SpanDistanceQuery(
 	                query,
 			this.segments.get(i),
-			constraint.getMinDistance(),
-			constraint.getMaxDistance(),
-			this.isInOrder(),
+			constraint,
 			true
 		    );
-		    sdquery.setExclusion(constraint.isExclusion());
 		    query = (SpanQuery) sdquery;
 		};
 	    };
@@ -188,7 +181,7 @@
 	        query,
 		this.segments.get(i),
 		this.constraints,
-		this.isInOrder(),
+		isInOrder,
 		true
 	    );
 	};