Index: bidspace/src/main/java/geniusweb/bidspace/BidsWithUtility.java
===================================================================
--- bidspace/src/main/java/geniusweb/bidspace/BidsWithUtility.java	(revision 48)
+++ bidspace/src/main/java/geniusweb/bidspace/BidsWithUtility.java	(revision 49)
@@ -39,4 +39,5 @@
 	 */
 	private final Map<Tuple<Integer, Interval>, ImmutableList<Bid>> cache = new HashMap<>();
+	private ImmutableList<Bid> emptylist = new FixedList<>();
 
 	/**
@@ -135,4 +136,29 @@
 	 * Create partial BidsWithUtil list considering only issues 0..n, with
 	 * utilities in given range.
+	 * <h2>Memory use</h2> Memory use of the return value can be large, if large
+	 * domains are given and the requested interval contains large numbers of
+	 * bids. To give some idea, here are some typical memory uses:
+	 * <table border="1">
+	 * <tr>
+	 * <td>domain</td>
+	 * <td>mem use (MB) of returned object</td>
+	 * <td>nr. of selected bids</td>
+	 * </tr>
+	 * <tr>
+	 * <td>jobs1</td>
+	 * <td>0.028</td>
+	 * <td>23</td>
+	 * </tr>
+	 * <tr>
+	 * <td>7issues1</td>
+	 * <td>34</td>
+	 * <td>346327</td>
+	 * </tr>
+	 * <tr>
+	 * <td>9issues1</td>
+	 * <td>98</td>
+	 * <td>37160666</td>
+	 * </tr>
+	 * </table>
 	 * 
 	 * @param n    the number of issueRanges to consider, we consider 0..n here.
@@ -178,5 +204,5 @@
 		IssueInfo info = issueInfo.get(n);
 		// issue is the first issuesWithRange.
-		String issue = issueInfo.get(n).getName();
+		String issue = info.getName();
 
 		if (n == 0)
@@ -184,5 +210,5 @@
 
 		// make new list, joining all sub-lists
-		ImmutableList<Bid> fulllist = new FixedList<>();
+		ImmutableList<Bid> fulllist = emptylist;
 		for (Value val : info.getValues()) {
 			BigDecimal weightedutil = info.getWeightedUtil(val);
@@ -191,7 +217,6 @@
 			ImmutableList<Bid> partialbids = get(n - 1, subgoal);
 
-			Bid bid = new Bid(issue, val);
 			ImmutableList<Bid> fullbids = new MapList<Bid, Bid>(
-					pbid -> pbid.merge(bid), partialbids);
+					pbid -> pbid.merge(new Bid(issue, val)), partialbids);
 			if (!fullbids.size().equals(BigInteger.ZERO))
 				fulllist = new JoinedList<Bid>(fullbids, fulllist);
Index: bidspace/src/test/java/geniusweb/bidspace/BidsWithUtilityTest.java
===================================================================
--- bidspace/src/test/java/geniusweb/bidspace/BidsWithUtilityTest.java	(revision 48)
+++ bidspace/src/test/java/geniusweb/bidspace/BidsWithUtilityTest.java	(revision 49)
@@ -33,4 +33,5 @@
 	private long expectedSize;
 	private int accuracy = 5;
+	private final static Runtime r = Runtime.getRuntime();
 
 	@Parameters
@@ -102,12 +103,52 @@
 		BigInteger domainsize = new AllBidsList(profile.getDomain()).size();
 
+		long presize = usedMemory();
 		long start = System.currentTimeMillis();
 		BidsWithUtility body = new BidsWithUtility(profile, accuracy);
 		ImmutableList<Bid> list = body.getBids(utilityGoal);
 		long end = System.currentTimeMillis();
+		long postsize = usedMemory();
 		System.out.println("run time: " + (end - start) / 1000. + "s");
-		System.out.println("Total size of bidspace:" + domainsize);
-		System.out.println("Result size: " + list.size());
+		System.out.println("Total size of complete domain:" + domainsize);
+		System.out.println("size of selection: " + list.size());
+		System.out.println("Memory use of selection(MB):"
+				+ (double) (postsize - presize) / (1024 * 1024));
 	}
 
+	/**
+	 * see https://www.geeksforgeeks.org/java-lang-runtime-class-in-java/
+	 * 
+	 * @return currently used memory after doing GC.
+	 * 
+	 */
+	public static long usedMemory() {
+		for (int n = 0; n < 4; n++)
+			gc1(); // repeat as gct seems getting more agressive then
+		return used();
+	}
+
+	/**
+	 * 
+	 * @return used heap mem. Does NOT GC. Uses {@link Runtime#totalMemory()}
+	 *         and {@link Runtime#freeMemory()} to avoid problems when JVM gets
+	 *         more system memory which can happen at any time.
+	 */
+	private static long used() {
+		return r.totalMemory() - r.freeMemory();
+	}
+
+	/**
+	 * repeat garbage collection till heap memory gets stable
+	 */
+	private static void gc1() {
+		long usedMem1 = used(), usedMem2 = Long.MAX_VALUE;
+		for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++i) {
+			r.runFinalization();
+			r.gc();
+			Thread.currentThread().yield();
+
+			usedMem2 = usedMem1;
+			usedMem1 = used();
+		}
+	}
 }
