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 95ff5cb..3368ef9 100644
--- a/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java
+++ b/src/main/java/de/ids_mannheim/korap/query/SpanDistanceQuery.java
@@ -12,6 +12,7 @@
 import org.apache.lucene.util.ToStringUtils;
 
 import de.ids_mannheim.korap.query.spans.DistanceExclusionSpan;
+import de.ids_mannheim.korap.query.spans.ElementDistanceExclusionSpan;
 import de.ids_mannheim.korap.query.spans.ElementDistanceSpans;
 import de.ids_mannheim.korap.query.spans.TokenDistanceSpans;
 import de.ids_mannheim.korap.query.spans.UnorderedElementDistanceSpans;
@@ -19,7 +20,9 @@
 
 /** Match two ordered or unordered Spans with minimum and maximum 
  * 	distance constraints. The distance unit can be word (token), 
- * 	sentence or paragraph. 
+ * 	sentence or paragraph. The distance constraint can also be
+ * 	specified to match some Spans which do not co-occur with some 
+ * 	other Spans within a min and max distance. 
  * 
  * 	@author margaretha
  * */
@@ -105,7 +108,8 @@
 		
 		if (this.elementQuery != null) {
 			if (isExclusion()){
-				
+				return new ElementDistanceExclusionSpan(this, context, acceptDocs, 
+						termContexts, isOrdered);
 			}			
 			else if (isOrdered){
 				return new ElementDistanceSpans(this, context, acceptDocs, 
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceExclusionSpan.java b/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceExclusionSpan.java
new file mode 100644
index 0000000..520ff75
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceExclusionSpan.java
@@ -0,0 +1,251 @@
+package de.ids_mannheim.korap.query.spans;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.lucene.index.AtomicReaderContext;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.index.TermContext;
+import org.apache.lucene.search.spans.Spans;
+import org.apache.lucene.util.Bits;
+
+import de.ids_mannheim.korap.query.SpanDistanceQuery;
+
+/** Span enumeration of the first spans which do NOT occur together 
+ * 	with the second spans within a range of some element-based distance 
+ * 	(sentence or paragraph). Note: The element distance unit does not 
+ * 	overlap to each other.
+ * 
+ * 	@author margaretha
+ * */
+public class ElementDistanceExclusionSpan extends DistanceSpans{
+
+	private Spans elements;
+	private boolean hasMoreElements;
+	private int elementPosition;
+	
+	private boolean isOrdered;
+	private boolean hasMoreSecondSpans;
+		
+	protected List<CandidateSpan> candidateList, targetList;	
+	private int currentDocNum;
+	
+	private int minDistance, maxDistance;
+	private int firstSpanPostion;
+	
+	public ElementDistanceExclusionSpan(SpanDistanceQuery query,
+			AtomicReaderContext context, Bits acceptDocs,
+			Map<Term, TermContext> termContexts, boolean isOrdered) 
+			throws IOException {
+		super(query, context, acceptDocs, termContexts);
+		
+		elements = query.getElementQuery().
+	  			getSpans(context, acceptDocs, termContexts);	  		
+  		hasMoreElements = elements.next();  		
+  		hasMoreSpans = firstSpans.next() && hasMoreElements;  		  		
+  		hasMoreSecondSpans = secondSpans.next();
+  		
+  		elementPosition=0;
+  		this.isOrdered = isOrdered;
+  		candidateList = new ArrayList<CandidateSpan>();
+  		targetList = new ArrayList<CandidateSpan>();
+  		currentDocNum = firstSpans.doc();
+  		
+  		minDistance = query.getMinDistance();
+		maxDistance = query.getMaxDistance();	
+	}
+
+	@Override
+	protected boolean advance() throws IOException {
+		while(!targetList.isEmpty() || (hasMoreSpans && ensureSameDoc(firstSpans, elements))){
+			if (!targetList.isEmpty()){
+				if (isTargetValid()) return true;
+				else continue;
+			}
+			if (checkFirstSpan()) return true;			
+		}
+		return false;
+	}
+	
+	private boolean isTargetValid() throws IOException{
+		CandidateSpan target = targetList.get(0);
+		targetList.remove(0);			
+		firstSpanPostion = target.getPosition();
+		filterCandidateList(firstSpanPostion);
+		collectRightCandidates();
+		
+		if (isWithinDistance()){
+			return false;
+		}		
+		setMatchProperties(target);
+		return true;
+	}
+	
+	private boolean checkFirstSpan() throws IOException{
+		if (firstSpans.doc() != currentDocNum){
+			currentDocNum = firstSpans.doc();
+			candidateList.clear();
+		}
+		
+		if (hasMoreSecondSpans) {
+			if (secondSpans.doc() == firstSpans.doc()){ 
+				return (findMatch() ? true : false);
+			}			
+			else if (secondSpans.doc() < firstSpans.doc()){
+				hasMoreSecondSpans = secondSpans.skipTo(firstSpans.doc());
+				return false;
+			}
+		}		
+		return (isFirstSpanValid() ? true : false);
+	}
+	
+	private boolean isFirstSpanValid() throws IOException{
+		if (candidateList.isEmpty()){
+			if (isFirstSpanInElement()){		
+				setMatchProperties(new CandidateSpan(firstSpans,elementPosition));
+				hasMoreSpans = firstSpans.next();
+				return true;
+			}
+			hasMoreSpans = firstSpans.next();
+			return false;		
+		}
+		return (findMatch() ? true : false);			
+	}
+	
+	private boolean advanceElementTo(Spans span) throws IOException{
+		while (hasMoreElements && 
+				elements.doc() == currentDocNum &&
+				elements.start() < span.end()){
+			
+			if (span.start() >= elements.start() &&
+					span.end() <= elements.end()){
+				return true;
+			}			
+			
+			hasMoreElements = elements.next();
+			elementPosition++;
+		}
+		return false;
+	}
+
+	private boolean findMatch() throws IOException {		
+		if (!isOrdered) collectLeftCandidates();
+		
+		if (isFirstSpanInElement()){
+			CandidateSpan target = new CandidateSpan(firstSpans,elementPosition);
+			hasMoreSpans = firstSpans.next();
+			// Checking the secondspans in the left side
+			if (!isOrdered && isWithinDistance()) return false;
+			// Checking the secondspans in the right side
+			collectRightCandidates();
+			if (isWithinDistance()) return false;
+			
+			setMatchProperties(target);
+			return true;
+		}
+		hasMoreSpans = firstSpans.next();
+		return false;
+	}
+	
+	private void collectRightCandidates() throws IOException{
+		while (hasMoreSecondSpans && secondSpans.doc() == currentDocNum){
+			
+			if (elementPosition > firstSpanPostion+maxDistance){
+				break;
+			}
+			if (hasMoreSpans && firstSpans.start() < secondSpans.start() &&
+					firstSpans.doc() == currentDocNum){
+				if (advanceElementTo(firstSpans)){
+					targetList.add(new CandidateSpan(firstSpans, elementPosition));
+				}
+				hasMoreSpans = firstSpans.next();
+				continue;
+			}
+			
+			if (advanceElementTo(secondSpans)){
+				candidateList.add(new CandidateSpan(secondSpans,elementPosition));
+			}
+			hasMoreSecondSpans = secondSpans.next();
+		}		
+	}
+	
+	private void collectLeftCandidates() throws IOException{
+		while(hasMoreSecondSpans && secondSpans.doc() == firstSpans.doc() &&
+				secondSpans.start() < firstSpans.end()){
+			if (advanceElementTo(secondSpans)){
+				candidateList.add(new CandidateSpan(secondSpans,elementPosition));
+				filterCandidateList(elementPosition);
+			}
+			hasMoreSecondSpans = secondSpans.next();
+		}	
+	}
+	
+	private boolean isWithinDistance(){
+		int actualDistance; 
+		for (CandidateSpan cs: candidateList){
+			actualDistance = cs.getPosition() - firstSpanPostion;
+			if (!isOrdered) actualDistance = Math.abs(actualDistance);
+			
+			if (minDistance <= actualDistance && actualDistance <= maxDistance)
+				return true;
+		}
+		return false;
+	}
+	
+	private boolean isFirstSpanInElement() throws IOException {
+		if (advanceElementTo(firstSpans)){
+			firstSpanPostion = elementPosition;
+			filterCandidateList(firstSpanPostion);
+			return true;
+		}
+		return false;
+	}
+	
+	private void filterCandidateList(int position){
+		
+		Iterator<CandidateSpan> i = candidateList.iterator();
+		CandidateSpan cs;
+		while(i.hasNext()){
+			cs = i.next();
+			if (cs.getPosition() == position || 
+					cs.getPosition()+maxDistance >= position){
+				break;
+			}			
+			i.remove();
+		}		
+	}	
+	
+	private void setMatchProperties(CandidateSpan match) throws IOException{
+		matchDocNumber = match.getDoc();
+		matchStartPosition = match.getStart();
+		matchEndPosition = match.getEnd();
+		
+  		if (collectPayloads && match.getPayloads() != null)
+	    	matchPayload.addAll(match.getPayloads());
+  		
+  		setMatchFirstSpan(match);
+  		  		
+  		log.trace("doc# {}, start {}, end {}",matchDocNumber,matchStartPosition,
+				matchEndPosition);		
+	}
+
+	@Override
+	public boolean skipTo(int target) throws IOException {
+		if (hasMoreSpans && firstSpans.doc() < target){
+			if (!firstSpans.skipTo(target)){
+				hasMoreSpans = false;
+				return false;
+			}
+		}
+		return advance();
+	}
+
+	@Override
+	public long cost() {
+		return elements.cost() + firstSpans.cost() + secondSpans.cost();
+	}
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceSpans.java
index b079c72..229004e 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceSpans.java
@@ -19,6 +19,8 @@
  * 	or a paragraph. All other child spans occurrence which are not in 
  * 	a sentence or a paragraph (with respect to the element distance type 
  * 	current used), are ignored.
+ * 	
+ * 	Note: elements cannot overlap to each other.
  * 
  * @author margaretha
  * */
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/OrderedDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/OrderedDistanceSpans.java
index 440d76f..732eb42 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/OrderedDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/OrderedDistanceSpans.java
@@ -109,8 +109,6 @@
 		
 		log.trace("doc# {}, start {}, end {}",matchDocNumber,matchStartPosition,
 				matchEndPosition);	
-		// System.out.println("firstspan "+getMatchFirstSpan().getStart()+" "+ getMatchFirstSpan().getEnd());
-		// System.out.println("secondspan "+getMatchSecondSpan().getStart()+" "+ getMatchSecondSpan().getEnd());
 	}
 
 	@Override