Java Code Examples for java.util.LinkedList#removeFirst()

@Override
protected void onBindView(View view) {
    super.onBindView(view);
    if (view.isInEditMode()) {
        return;
    }
    if (view instanceof ViewGroup) {
        ViewGroup viewGroup = (ViewGroup) view;
        LinkedList<ViewGroup> queue = new LinkedList<>();
        queue.add(viewGroup);
        while (!queue.isEmpty()) {
            ViewGroup current = queue.removeFirst();
            for (int i = 0; i < current.getChildCount(); i++) {
                if (current.getChildAt(i) instanceof Switch) {
                    ATH.setTint(current.getChildAt(i), ThemeStore.accentColor(view.getContext()));
                    return;
                } else if (current.getChildAt(i) instanceof ViewGroup) {
                    queue.addLast((ViewGroup) current.getChildAt(i));
                }
            }
        }
    }

}
 

public static int bfs (HashMap<String,ArrayList<String>> adjList, String src, String dest) {
	if (src.equals(dest)) return 0;
	
	LinkedList<String> queue=new LinkedList<>();
	HashMap<String,Integer> dist=new HashMap<>();
	HashSet<String> visited=new HashSet<>();
	
	queue.add(src);
	visited.add(src);
	dist.put(src,0);
	
	while (!queue.isEmpty()) {
		String curr=queue.removeFirst();
		if (curr.equals(dest)) return dist.get(curr);
		
		for (String neighbour : adjList.get(curr)) if (!dist.containsKey(neighbour)) {
			queue.addLast(neighbour);
			dist.put(neighbour,dist.get(curr)+1);
		}
	}
	return -1;
}
 

public int[] maxSlidingWindow(int[] nums, int k) {
    int len = nums.length;
    if (len == 0) {
        return new int[0];
    }
    int[] res = new int[len - k + 1];
    LinkedList<Integer> queue = new LinkedList<>();
    for (int i = 0; i < len; i++) {
        if (i >= k && queue.getFirst() == i - k) {
            queue.removeFirst();
        }
        while (!queue.isEmpty() && nums[queue.getLast()] <= nums[i]) {
            queue.removeLast();
        }
        queue.add(i);
        if (i >= k - 1) {
            res[i - k + 1] = nums[queue.getFirst()];
        }
    }
    return res;
}
 

/**
 * Creates the new instructions, inlining each instantiation of each
 * subroutine until the code is fully elaborated.
 */
private void emitCode() {
    LinkedList<Instantiation> worklist = new LinkedList<Instantiation>();
    // Create an instantiation of the "root" subroutine, which is just the
    // main routine
    worklist.add(new Instantiation(null, mainSubroutine));

    // Emit instantiations of each subroutine we encounter, including the
    // main subroutine
    InsnList newInstructions = new InsnList();
    List<TryCatchBlockNode> newTryCatchBlocks = new ArrayList<TryCatchBlockNode>();
    List<LocalVariableNode> newLocalVariables = new ArrayList<LocalVariableNode>();
    while (!worklist.isEmpty()) {
        Instantiation inst = worklist.removeFirst();
        emitSubroutine(inst, worklist, newInstructions, newTryCatchBlocks,
                newLocalVariables);
    }
    instructions = newInstructions;
    tryCatchBlocks = newTryCatchBlocks;
    localVariables = newLocalVariables;
}
 

/**
 * Creates the new instructions, inlining each instantiation of each
 * subroutine until the code is fully elaborated.
 */
private void emitCode() {
    LinkedList<Instantiation> worklist = new LinkedList<Instantiation>();
    // Create an instantiation of the "root" subroutine, which is just the
    // main routine
    worklist.add(new Instantiation(null, mainSubroutine));

    // Emit instantiations of each subroutine we encounter, including the
    // main subroutine
    InsnList newInstructions = new InsnList();
    List<TryCatchBlockNode> newTryCatchBlocks = new ArrayList<TryCatchBlockNode>();
    List<LocalVariableNode> newLocalVariables = new ArrayList<LocalVariableNode>();
    while (!worklist.isEmpty()) {
        Instantiation inst = worklist.removeFirst();
        emitSubroutine(inst, worklist, newInstructions, newTryCatchBlocks,
                newLocalVariables);
    }
    instructions = newInstructions;
    tryCatchBlocks = newTryCatchBlocks;
    localVariables = newLocalVariables;
}
 

@Override
public Cursor querySearchDocuments(String rootId, String query, String[] projection)
        throws FileNotFoundException {
    Log.v(TAG, "querySearchDocuments");

    // Create a cursor with the requested projection, or the default projection.
    final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
    final File parent = getFileForDocId(rootId);

    // This example implementation searches file names for the query and doesn't rank search
    // results, so we can stop as soon as we find a sufficient number of matches.  Other
    // implementations might use other data about files, rather than the file name, to
    // produce a match; it might also require a network call to query a remote server.

    // Iterate through all files in the file structure under the root until we reach the
    // desired number of matches.
    final LinkedList<File> pending = new LinkedList<File>();

    // Start by adding the parent to the list of files to be processed
    pending.add(parent);

    // Do while we still have unexamined files, and fewer than the max search results
    while (!pending.isEmpty() && result.getCount() < MAX_SEARCH_RESULTS) {
        // Take a file from the list of unprocessed files
        final File file = pending.removeFirst();
        if (file.isDirectory()) {
            // If it's a directory, add all its children to the unprocessed list
            Collections.addAll(pending, file.listFiles());
        } else {
            // If it's a file and it matches, add it to the result cursor.
            if (file.getName().toLowerCase().contains(query)) {
                includeFile(result, null, file);
            }
        }
    }
    return result;
}
 

@Override
public LinkedList<AssignmentNode> differentiate(LinkedList<AssignmentNode> toDerive, MultivectorComponent variable) {
    try {
        MaximaConnection connection = new ProcessBuilderMaximaConnection(maximaCommand);
        connection.setProgressListeners(new LoggingListenerGroup());
        
        MaximaInput input = new MaximaInput();
        input.add("display2d:false;"); // very important!
        input.add("ratprint:false;"); // very important!
        input.add("keepfloat:true;");
        fillMaximaInput(toDerive, input, variable);
        input.add("quit();"); // very important!

        MaximaOutput output = connection.optimizeWithMaxima(input);

        //connect in and output
        LinkedList<String> connected = new LinkedList<String>();
        MaximaRoutines.groupMaximaInAndOutputs(connected, output);

        connected.removeFirst(); // remove display2d
        connected.removeFirst(); // remove ratsimp
        connected.removeFirst(); // remove keepfloat
        
        LinkedList<AssignmentNode> result = new LinkedList<AssignmentNode>();
        ListIterator<AssignmentNode> listIterator = toDerive.listIterator();
        for (String io : connected) {
            AssignmentNode node = listIterator.next();
            Expression exp = MaximaRoutines.getExpressionFromMaximaOutput(io);
            result.add(new AssignmentNode(node.getGraph(), new MultivectorComponent(node.getVariable().getName(), 0), exp));
        }

        return result; 
    } catch (OptimizationException ex) {
        Logger.getLogger(MaximaDifferentiater.class.getName()).log(Level.SEVERE, null, ex);
    }
    return null;
}
 

/**
 * 两个链表前面的结点都是相同的，找到最后一个相同的结点就是最低公共祖先
 */
private Node getLastSameNode(LinkedList<Node> path1, LinkedList<Node> path2) {
    Node lastSameNode = null;
    while (!path1.isEmpty() && !path2.isEmpty()) {
        if (path1.peekFirst() == path2.removeFirst()) {
            lastSameNode = path1.removeFirst();
        } else {
            return lastSameNode;
        }
    }
    return lastSameNode;
}
 

/** Creates all rules with length<=minComplexity. */
@Override
public LinkedList<Hypothesis> init(int minComplexity) {
	LinkedList<Hypothesis> border = new LinkedList<Hypothesis>();
	LinkedList<Hypothesis> result = new LinkedList<Hypothesis>();

	// Add all hypothesis of lenght 1 to border.
	for (int attributeIndex = 0; attributeIndex < allLiterals.length; attributeIndex++) {
		for (int valueIndex = 0; valueIndex < allLiterals[attributeIndex].length; valueIndex++) {
			border.addLast(new Rule(allLiterals[attributeIndex][valueIndex], POSITIVE_CLASS)); // Create
																								// h->Y+
																								// first.
		}
	}

	while (!border.isEmpty()) {
		Rule rule = (Rule) border.removeFirst();
		result.addLast(rule); // Add h->Y+ to result.
		if (createAllHypothesis) {
			result.addLast(new Rule(rule.getLiterals(), NEGATIVE_CLASS)); // Add h->Y- to
																			// result.
		}

		// No need to refine anymore if rule length already is equal to minComplexity.
		if (rule.getComplexity() < minComplexity) {
			border.addAll(rule.refine()); // Add h->Y+ only
		}
	}
	return result;
}
 

/**
 * Expands the event queue capacity, or truncates if capacity is lower than
 * current capacity. Then only the newest entries are kept
 * @param self self reference
 * @param newCapacity new capacity
 */
@Function(attributes = Attribute.NOT_ENUMERABLE, where = Where.CONSTRUCTOR)
public static void expandEventQueueCapacity(final Object self, final Object newCapacity) {
    final LinkedList<RuntimeEvent<?>> q = getEventQueue(self);
    final int nc = JSType.toInt32(newCapacity);
    while (q.size() > nc) {
        q.removeFirst();
    }
    setEventQueueCapacity(self, nc);
}
 

/**
 * {@inheritDoc}
 */
public long sizeOf(final Object obj) {


   final Map<Object, Object> visited = new IdentityHashMap<Object, Object>(11);

   final LinkedList<Object> stack = new LinkedList<Object>();


   long result = calculate(obj, visited, stack);
   while (!stack.isEmpty()) {

      final Object pop = stack.removeFirst();
      result += calculate(pop, visited, stack);
   }
   visited.clear();
   return result;
}
 

public static int deepHashCode(Object obj) {
	Set visited = new HashSet();
	LinkedList<Object> stack = new LinkedList<Object>();
	stack.addFirst(obj);
	int hash = 0;

	while (!stack.isEmpty()) {
		obj = stack.removeFirst();
		if (obj == null || visited.contains(obj)) {
			continue;
		}

		visited.add(obj);

		if (obj.getClass().isArray()) {
			int len = Array.getLength(obj);
			for (int i = 0; i < len; i++) {
				stack.addFirst(Array.get(obj, i));
			}
			continue;
		}

		if (obj instanceof Collection) {
			stack.addAll(0, (Collection) obj);
			continue;
		}

		if (obj instanceof Map) {
			stack.addAll(0, ((Map) obj).keySet());
			stack.addAll(0, ((Map) obj).values());
			continue;
		}

		if (hasCustomHashCode(obj.getClass())) {
			hash += obj.hashCode();
			continue;
		}

		Collection<Field> fields = getDeepDeclaredFields(obj.getClass());
		for (Field field : fields) {
			try {
				stack.addFirst(field.get(obj));
			} catch (Exception ignored) {
			}
		}
	}
	return hash;
}
 

/** Find the nearest parent with a non-null, non-empty Area, and interpolate from {@code nd} to it.
 *
 * @param nd The node to start interpolating from, towards its nearest parent with an area.
 * @param node_centric If true, consider areas relative to the node coordinates. If false, relative to the overall AreaTree.
 *
 * @throws Exception */
public boolean interpolateTowardsParent(final Node<Area> nd, final boolean node_centric, final boolean always_use_distance_map) throws Exception {
	if (null == nd || null == nd.parent) return false;
	Area first = nd.getData();
	if (null == first || first.isEmpty()) {
		return false;
	}
	final LinkedList<Node<Area>> chain = new LinkedList<Node<Area>>();
	Node<Area> p = nd.parent;
	while (null != p && (null == p.getData() || p.getData().isEmpty())) {
		chain.add(p);
		p = p.parent;
	}
	if (p == nd.parent) {
		// Nothing to interpolate
		return false;
	}

	Area last = p.getData();

	int minx = 0, miny = 0;
	if (node_centric) {
		// Make areas relative to the nodes:
		first = first.createTransformedArea(new AffineTransform(1, 0, 0, 1, -nd.x, -nd.y));
		last = last.createTransformedArea(new AffineTransform(1, 0, 0, 1, -p.x, -p.y));
		// Remove translations
		final Rectangle bfirst = first.getBounds();
		final Rectangle blast = last.getBounds();
		minx = Math.min(bfirst.x, blast.x);
		miny = Math.min(bfirst.y, blast.y);
		final AffineTransform rmtrans = new AffineTransform(1, 0, 0, 1, -minx, -miny);
		first = first.createTransformedArea(rmtrans);
		last = last.createTransformedArea(rmtrans);
	}
	// Interpolate
	final Area[] as;
	if (!always_use_distance_map && first.isSingular() && last.isSingular()) {
		as = AreaUtils.singularInterpolation(first, last, chain.size());
	} else {
		as = AreaUtils.manyToManyInterpolation(first, last, chain.size());
	}
	// Assign each area
	for (final Area interpolated : as) {
		final Node<Area> target = chain.removeFirst();
		if (node_centric) {
			interpolated.transform(new AffineTransform(1, 0, 0, 1, minx + target.x, miny + target.y));
		}
		target.setData(interpolated);
	}

	return true;
}
 

/**
 * Computes the pre-image of sst on the set outputNonMin
 * 
 * @throws TimeoutException
 */
public static <A, B, C> SFA<A, C> preImage(SST<A, B, C> sstWithEps, SFA<A, C> outputNonMin,
		BooleanAlgebraSubst<A, B, C> ba) throws TimeoutException {
	SFA<A, C> output = outputNonMin.minimize(ba);
	SST<A, B, C> sst = sstWithEps.removeEpsilonMoves(ba);

	Collection<SFAMove<A, C>> transitions = new ArrayList<SFAMove<A, C>>();
	Collection<Integer> finalStates = new HashSet<Integer>();
	Integer initialState = 0;

	// A state is a pair (q, f) where q is a state of the sst and f: X -> QO
	// -> QO is a function
	// mapping each variable x to a function from QO to QO (the
	// summarization)
	Map<Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>>, Integer> reached = new HashMap<Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>>, Integer>();
	LinkedList<Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>>> toVisit = new LinkedList<Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>>>();

	// The initial state is the identity for every variable
	HashMap<Integer, Integer> identityStateMap = new HashMap<Integer, Integer>();
	HashMap<Integer, HashMap<Integer, Integer>> identityMap = new HashMap<Integer, HashMap<Integer, Integer>>();
	for (int stateId : output.getStates())
		identityStateMap.put(stateId, stateId);
	for (int varId = 0; varId < sst.variableCount; varId++)
		identityMap.put(varId, identityStateMap);

	Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>> initialStatePair = new Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>>(
			sst.initialState, identityMap);
	reached.put(initialStatePair, 0);
	toVisit.add(initialStatePair);

	// do a DFS and look for reachable states
	while (!toVisit.isEmpty()) {
		Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>> currState = toVisit.removeFirst();
		int currStateId = reached.get(currState);

		int sstState = currState.first;
		HashMap<Integer, HashMap<Integer, Integer>> currFun = currState.second;

		// set final states to those for which the output func summarized on
		// initial state gives a final state of O
		if (sst.isFinalState(sstState)) {
			Integer fromqoOnOutputFunction = sst.outputFunction.get(sstState).getInitStateSummary(currFun, output,
					ba);
			if (fromqoOnOutputFunction != null && output.getFinalStates().contains(fromqoOnOutputFunction))
				finalStates.add(currStateId);
		}

		// For each move of the sst compute the next state
		for (SSTInputMove<A, B, C> t : sst.getInputMovesFrom(sstState)) {

			Collection<Pair<HashMap<Integer, HashMap<Integer, Integer>>, A>> nextFuns = t.variableUpdate
					.getNextSummary(currFun, t.guard, output, ba);
			for (Pair<HashMap<Integer, HashMap<Integer, Integer>>, A> pair : nextFuns) {

				Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>> nextState = new Pair<Integer, HashMap<Integer, HashMap<Integer, Integer>>>(
						t.to, pair.first);

				int nextStateId = getStateId(nextState, reached, toVisit);

				transitions.add(new SFAInputMove<A, C>(currStateId, nextStateId, pair.second));
			}
		}

	}

	return SFA.MkSFA(transitions, initialState, finalStates, ba);
}
 

/**
 * Translates the parameters on the given proposition definition to create an expression for evaluation.
 * The proposition parameters are defined in a reverse-polish notation so a stack is used for
 * evaluation purposes.
 * 
 * @param propositionDefinition the proposition definition to translate
 * 
 * @return the translated expression for the given proposition, this
 * expression, when evaluated, will return a Boolean.
 */
protected Expression<Boolean> translateToExpression(PropositionDefinition propositionDefinition) {
	LinkedList<Expression<? extends Object>> stack = new LinkedList<Expression<? extends Object>>();
	for (PropositionParameter parameter : propositionDefinition.getParameters()) {
		PropositionParameterType parameterType = PropositionParameterType.fromCode(parameter.getParameterType());
		if (parameterType == PropositionParameterType.CONSTANT) {
			// TODO - need some way to define data type on the prop parameter as well?  Not all constants will actually be String values!!!
			stack.addFirst(new ConstantExpression<String>(parameter.getValue()));
		} else if (parameterType == PropositionParameterType.FUNCTION) {
			String functionId = parameter.getValue();
			FunctionDefinition functionDefinition = functionRepositoryService.getFunction(functionId);
			if (functionDefinition == null) {
				throw new RepositoryDataException("Unable to locate function with the given id: " + functionId);
			}
			FunctionTypeService functionTypeService = typeResolver.getFunctionTypeService(functionDefinition);
			Function function = functionTypeService.loadFunction(functionDefinition);
			// TODO throw an exception if function is null?
			List<FunctionParameterDefinition> parameters = functionDefinition.getParameters();
			if (stack.size() < parameters.size()) {
				throw new RepositoryDataException("Failed to initialize custom function '" + functionDefinition.getNamespace() + " " + functionDefinition.getName() +
						"'.  There were only " + stack.size() + " values on the stack but function requires at least " + parameters.size());
			}
			List<Expression<? extends Object>> arguments = new ArrayList<Expression<? extends Object>>();
			// work backward through the list to match params to the stack
			for (int index = parameters.size() - 1; index >= 0; index--) {
				FunctionParameterDefinition parameterDefinition = parameters.get(index);
				// TODO need to check types here? expression object probably needs a getType on it so that we can confirm that the types will be compatible?
                   parameterDefinition.getParameterType();
				Expression<? extends Object> argument = stack.removeFirst();
				arguments.add(argument);
			}

               String[] parameterTypes = getFunctionParameterTypes(functionDefinition);
			stack.addFirst(new FunctionExpression(function, parameterTypes, arguments, getComparisonOperatorService()));

		} else if (parameterType == PropositionParameterType.OPERATOR) {
			ComparisonOperator operator = ComparisonOperator.fromCode(parameter.getValue());
			if (stack.size() < 2) {
				throw new RepositoryDataException("Failed to initialize expression for comparison operator " +
                           operator + " because a sufficient number of arguments was not available on the stack.  "
                           + "Current contents of stack: " + stack.toString());
			}
			Expression<? extends Object> rhs = stack.removeFirst();
			Expression<? extends Object> lhs = stack.removeFirst();
			stack.addFirst(new BinaryOperatorExpression(operator, lhs, rhs));
		} else if (parameterType == PropositionParameterType.TERM) {
			String termId = parameter.getValue();

			TermDefinition termDefinition = getTermRepositoryService().getTerm(termId);
			if (termDefinition == null) { throw new RepositoryDataException("unable to load term with id " + termId);}
			Term term = translateTermDefinition(termDefinition);
			
			stack.addFirst(new TermExpression(term));
		}
	}
	if (stack.size() != 1) {
		throw new RepositoryDataException("Final contents of expression stack are incorrect, there should only be one entry but was " + stack.size() +".  Current contents of stack: " + stack.toString());
	}
	return new BooleanValidatingExpression(stack.removeFirst());
}
 

private void setInitVars(RootStatement root) {
  boolean thisVar = !method.hasModifier(CodeConstants.ACC_STATIC);

  MethodDescriptor md = methodDescriptor;

  if (thisVar) {
    StructClass cl = (StructClass) DecompilerContext.getProperty(DecompilerContext.CURRENT_CLASS);
    VarType clType = new VarType(CodeConstants.TYPE_OBJECT, 0, cl.qualifiedName);
    mapExprentMinTypes.put(new VarVersionPair(0, 1), clType);
    mapExprentMaxTypes.put(new VarVersionPair(0, 1), clType);
  }

  int varIndex = 0;
  for (int i = 0; i < md.params.length; i++) {
    mapExprentMinTypes.put(new VarVersionPair(varIndex + (thisVar ? 1 : 0), 1), md.params[i]);
    mapExprentMaxTypes.put(new VarVersionPair(varIndex + (thisVar ? 1 : 0), 1), md.params[i]);
    varIndex += md.params[i].stackSize;
  }

  // catch variables
  LinkedList<Statement> stack = new LinkedList<>();
  stack.add(root);

  while (!stack.isEmpty()) {
    Statement stat = stack.removeFirst();

    List<VarExprent> lstVars = null;
    if (stat.type == Statement.TYPE_CATCHALL) {
      lstVars = ((CatchAllStatement) stat).getVars();
    } else if (stat.type == Statement.TYPE_TRYCATCH) {
      lstVars = ((CatchStatement) stat).getVars();
    }

    if (lstVars != null) {
      for (VarExprent var : lstVars) {
        mapExprentMinTypes.put(new VarVersionPair(var.getIndex(), 1), var.getVarType());
        mapExprentMaxTypes.put(new VarVersionPair(var.getIndex(), 1), var.getVarType());
      }
    }

    stack.addAll(stat.getStats());
  }
}
 

private UploadSession getNextBestSession( LinkedList best ) {
	count++;
	System.out.print( "getNextBestSession [" +count+"] best.size=" +best.size()+ "  " );

	if( !best.isEmpty() ) {
		UploadSession session = (UploadSession)best.removeFirst();   //get next

		if( !isAlreadySlotted( session ) ) {   //found an unslotted session

			System.out.println( "OK found session [" +session.getStatsTrace()+ "]" );

			return session;
		}

		System.out.println( "FAIL already-slotted session [" +session.getStatsTrace()+ "]" );

		return getNextBestSession( best );			//oops, already been slotted, try again
	}

	return null;
}
 

public static void main (String [] args) throws Exception {
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	int testCaseCount=Integer.parseInt(br.readLine());
	for (int testCase=0;testCase<testCaseCount;testCase++) {
		boolean [][] edges=new boolean [26][26];
		String s;
		while ((s=br.readLine()).charAt(0)!='*') {
			edges[s.charAt(1)-'A'][s.charAt(3)-'A']=true;
			edges[s.charAt(3)-'A'][s.charAt(1)-'A']=true;
		}
		
		boolean [] nodeExists=new boolean [26];
		StringTokenizer st=new StringTokenizer(br.readLine(), ",");
		while (st.hasMoreTokens()) nodeExists[st.nextToken().charAt(0)-'A']=true;
		
		int acronsCount=0, treeCount=0;
		boolean [] visited=new boolean[26];
		for (int i=0;i<26;i++) if (nodeExists[i] && !visited[i]) {
			int edgesCount=0;
			for (int e=0;e<26;e++) if (edges[i][e]) edgesCount++;
			if (edgesCount==0) {
				visited[i]=true;
				acronsCount++;
			} else {
				boolean tree=true;
				LinkedList<Integer> queue=new LinkedList<>();
				queue.add(i);
				
				boolean [][] edgeVisited=new boolean[26][26];
				while (queue.size()>0) {
					int currI=queue.removeFirst();
					if (visited[currI]) {
						tree=false;
						break;
					} else {
						visited[currI]=true;
						for (int e=0;e<26;e++) if (edges[currI][e] && !edgeVisited[currI][e] && !edgeVisited[e][currI]) {
							queue.add(e);
							edgeVisited[currI][e]=true;
							edgeVisited[e][currI]=true;
						}
					}
				}
				if (tree) treeCount++;
			}
		}
		
		StringBuilder sb=new StringBuilder();
		sb.append("There are ");
		sb.append(treeCount);
		sb.append(" tree(s) and ");
		sb.append(acronsCount);
		sb.append(" acorn(s).");
		System.out.println(sb.toString());
	}
	
}
 

private boolean processResponse(LinkedList<Call> responseQueue,
                                boolean inHandler) throws IOException {
  boolean error = true;
  boolean done = false;       // there is more data for this channel.
  int numElements = 0;
  Call call = null;
  try {
    synchronized (responseQueue) {
      //
      // If there are no items for this channel, then we are done
      //
      numElements = responseQueue.size();
      if (numElements == 0) {
        error = false;
        return true;              // no more data for this channel.
      }
      //
      // Extract the first call
      //
      call = responseQueue.removeFirst();
      SocketChannel channel = call.connection.channel;
      if (LOG.isDebugEnabled()) {
        LOG.debug(getName() + ": responding to #" + call.id + " from " +
                  call.connection);
      }
      //
      // Send as much data as we can in the non-blocking fashion
      //
      int numBytes = channelWrite(channel, call.response);
      if (numBytes < 0) {
        return true;
      }
      if (!call.response.hasRemaining()) {
        call.connection.decRpcCount();
        if (numElements == 1) {    // last call fully processes.
          done = true;             // no more data for this channel.
        } else {
          done = false;            // more calls pending to be sent.
        }
        if (LOG.isDebugEnabled()) {
          LOG.debug(getName() + ": responding to #" + call.id + " from " +
                    call.connection + " Wrote " + numBytes + " bytes.");
        }
      } else {
        //
        // If we were unable to write the entire response out, then 
        // insert in Selector queue. 
        //
        call.connection.responseQueue.addFirst(call);
        
        if (inHandler) {
          // set the serve time when the response has to be sent later
          call.timestamp = System.currentTimeMillis();
          
          incPending();
          try {
            // Wakeup the thread blocked on select, only then can the call 
            // to channel.register() complete.
            writeSelector.wakeup();
            channel.register(writeSelector, SelectionKey.OP_WRITE, call);
          } catch (ClosedChannelException e) {
            //Its ok. channel might be closed else where.
            done = true;
          } finally {
            decPending();
          }
        }
        if (LOG.isDebugEnabled()) {
          LOG.debug(getName() + ": responding to #" + call.id + " from " +
                    call.connection + " Wrote partial " + numBytes + 
                    " bytes.");
        }
      }
      error = false;              // everything went off well
    }
  } finally {
    if (error && call != null) {
      LOG.warn(getName()+", call " + call + ": output error");
      done = true;               // error. no more data for this channel.
      closeConnection(call.connection);
    }
  }
  return done;
}
 

private void filterOnDominance(DominatorTreeExceptionFilter filter) {

        DominatorEngine engine = filter.getDomEngine();

        for (Integer head : new HashSet<>(mapExtPostdominators.keySet())) {

            FastFixedSet<Integer> setPostdoms = mapExtPostdominators.get(head);

            LinkedList<Statement> stack = new LinkedList<>();
            LinkedList<FastFixedSet<Integer>> stackPath = new LinkedList<>();

            stack.add(statement.getStats().getWithKey(head));
            stackPath.add(factory.spawnEmptySet());

            Set<Statement> setVisited = new HashSet<>();

            setVisited.add(stack.getFirst());

            while (!stack.isEmpty()) {

                Statement stat = stack.removeFirst();
                FastFixedSet<Integer> path = stackPath.removeFirst();

                if (setPostdoms.contains(stat.id)) {
                    path.add(stat.id);
                }

                if (path.contains(setPostdoms)) {
                    continue;
                }

                if (!engine.isDominator(stat.id, head)) {
                    setPostdoms.complement(path);
                    continue;
                }

                for (StatEdge edge : stat.getSuccessorEdges(StatEdge.TYPE_REGULAR)) {

                    Statement edge_destination = edge.getDestination();

                    if (!setVisited.contains(edge_destination)) {

                        stack.add(edge_destination);
                        stackPath.add(path.getCopy());

                        setVisited.add(edge_destination);
                    }
                }
            }

            if (setPostdoms.isEmpty()) {
                mapExtPostdominators.remove(head);
            }
        }
    }