diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/AbstractSyntaxTree.java b/src/main/java/de/ids_mannheim/korap/query/serialize/AbstractSyntaxTree.java
index 81efa6e..7b9a7e4 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/AbstractSyntaxTree.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/AbstractSyntaxTree.java
@@ -179,7 +179,7 @@
 		group.put("frames", Arrays.asList(allowedFrames));
 		group.put("operands", new ArrayList<Object>());
 		// DEPRECATED 'frame'
-		if (classRefCheck.length==0) classRefCheck = new String[]{"classRefCheck:includes"};
+		if (classRefCheck == null || classRefCheck.length==0) classRefCheck = new String[]{"classRefCheck:includes"};
 		String frame = "";
 		
 		if (allowedFrames.length==0 && classRefCheck[0]=="classRefCheck:includes") {
@@ -320,18 +320,24 @@
 		return makeReference(classRefs, "focus");
 	}
 	
-	protected LinkedHashMap<String, Object> makeReference(int classRef, String operation) {
+	protected LinkedHashMap<String, Object> makeReference(int classRef, String operation, boolean setBySystem) {
 		ArrayList<Integer> classRefs = new ArrayList<Integer>();
+		if (setBySystem) classRef = classRef+128;
 		classRefs.add(classRef);
 		return makeReference(classRefs, operation);
 	}
 	
-	protected LinkedHashMap<String, Object> makeReference(int classRef) {
+	protected LinkedHashMap<String, Object> makeReference(int classRef, boolean setBySystem) {
 		ArrayList<Integer> classRefs = new ArrayList<Integer>();
+		if (setBySystem) classRef = classRef+128;
 		classRefs.add(classRef);
 		return makeReference(classRefs, "focus");
 	}
 	
+	protected LinkedHashMap<String, Object> makeReference(int classRef) {
+		return makeReference(classRef, false);
+	}
+	
 	protected LinkedHashMap<String, Object> makeResetReference() {
 		LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
 		group.put("@type", "korap:reference");
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/AqlTree.java b/src/main/java/de/ids_mannheim/korap/query/serialize/AqlTree.java
index 79d5fcb..64141aa 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/AqlTree.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/AqlTree.java
@@ -390,6 +390,18 @@
 					
 				// Get operands list before possible re-assignment of 'group' (see following 'if')
 				operands  = (ArrayList<Object>) group.get("operands");
+				
+				ParseTree leftChildSpec = getFirstChildWithCat(node.getChild(i).getChild(0), "@l");
+				ParseTree rightChildSpec = getFirstChildWithCat(node.getChild(i).getChild(0), "@r");
+				if (leftChildSpec != null || rightChildSpec != null) { //XXX
+					String frame = (leftChildSpec!=null) ? "frames:startswith" : "frames:endswith";
+					LinkedHashMap<String,Object> positionGroup = makePosition(new String[]{frame}, null);
+					operand2 = wrapInClass(operand2, ++classCounter);
+					((ArrayList<Object>) positionGroup.get("operands")).add(group);
+					((ArrayList<Object>) positionGroup.get("operands")).add(makeReference(classCounter,true));
+					group = positionGroup;
+				}
+				
 				// Wrap in reference object in case other relations are following
 				if (i < node.getChildCount()-2) {
 					group = wrapInReference(group, classCounter);
@@ -476,8 +488,6 @@
 			ParseTree rangeSpec = getFirstChildWithCat(operatorNode, "rangeSpec");
 			LinkedHashMap<String,Object> term = makeTerm();
 			term.put("layer", "c");
-			if (leftChildSpec != null) relation.put("index", 0);
-			if (rightChildSpec != null) relation.put("index", -1);
 			if (qName != null) term = parseQNameNode(qName);
 			if (edgeSpecNode != null) {
 				LinkedHashMap<String,Object> edgeSpec = parseEdgeSpec(edgeSpecNode);
@@ -726,7 +736,7 @@
 		 * For testing
 		 */
 		String[] queries = new String[] {
-				"cat=\"S\" & node & #1 >@l[func=\"SB\"] #2"
+				"cat=\"S\" & node & #1 >@l #2"
 		};
 		//		AqlTree.verbose=true;
 		for (String q : queries) {
