diff --git a/full/src/main/java/de/ids_mannheim/korap/config/NamedVCLoader.java b/full/src/main/java/de/ids_mannheim/korap/config/NamedVCLoader.java
index 115405e..8ef8070 100644
--- a/full/src/main/java/de/ids_mannheim/korap/config/NamedVCLoader.java
+++ b/full/src/main/java/de/ids_mannheim/korap/config/NamedVCLoader.java
@@ -4,6 +4,7 @@
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Arrays;
 import java.util.zip.GZIPInputStream;
 
 import javax.management.RuntimeErrorException;
@@ -77,6 +78,8 @@
             throw new IOException("Directory " + dir + " is not valid");
         }
 
+        jlog.info(Arrays.toString(d.list()));
+        
         for (File file : d.listFiles()) {
             if (!file.exists()) {
                 throw new IOException("File " + file + " is not found.");
diff --git a/full/src/main/resources/ehcache.xml b/full/src/main/resources/ehcache.xml
index da9acda..2801a59 100644
--- a/full/src/main/resources/ehcache.xml
+++ b/full/src/main/resources/ehcache.xml
@@ -59,6 +59,6 @@
 		maxBytesLocalDisk="1G"
 		diskExpiryThreadIntervalSeconds = "120" > 
 		<persistence strategy="localTempSwap"/>
-		<sizeOfPolicy maxDepth="2000" maxDepthExceededBehavior="abort" />
+		<sizeOfPolicy maxDepth="3000" maxDepthExceededBehavior="abort" />
 	</cache>        
 </ehcache>
