Attempt to find a smelting recipe that results in the requested output.
@param output
@return an ItemStack representing the required input.
974503
public static ItemStack getSmeltingRecipeForRequestedOutput(String output)
    {
        ItemStack target = MinecraftTypeHelper.getItemStackFromParameterString(output);
        Iterator<?> furnaceIt = FurnaceRecipes.instance().getSmeltingList().keySet().iterator();
        while (furnaceIt.hasNext())
        {
            ItemStack isInput = (ItemStack)furnaceIt.next();
            ItemStack isOutput = (ItemStack)FurnaceRecipes.instance().getSmeltingList().get(isInput);
            if (itemStackIngredientsMatch(target, isOutput))
                return isInput;
        }
        return null;
    }
837792
protected void stageOutput(final String output) {
        boolean print = getPhaseConfiguration().isVerbose();
        if (print) {
            output(INDENT + INDENT + output);
        }
    }
950869
public static Stack getStack() {
        Stack stack = interceptionContexts.get();
        if (stack == null) {
            stack = new Stack(interceptionContexts);
            interceptionContexts.set(stack);
        }
        return stack;
    }
177070
public T get(String variable, String frame, int iteration, FrameIter parentFrameIter, boolean enforceExistence) {
        //TODO eventually we'll cache and reuse VarId objects here to avoid garbage generation on lookup etc
        VarId varId = newVarId(variable, frame, iteration, parentFrameIter);
        T out = nodeOutputs.get(varId);
        if(enforceExistence) {
            Preconditions.checkNotNull(out, "No output found for variable %s (frame %s, iteration %s)", variable, frame, iteration);
        }
        return out;
    }
598551
private void createChip(T item) {
        JFXChip<T> chip = null;
        try {
            if (getSkinnable().getChipFactory() != null) {
                chip = getSkinnable().getChipFactory().apply(getSkinnable(), item);
            } else {
                chip = new JFXDefaultChip<T>(getSkinnable(), item);
            }
        } catch (Exception e) {
            throw new RuntimeException("can't create chip for item '" + item +
                                       "' make sure to override the string converter and return null if text input is not valid.", e);
        }
        int size = root.getChildren().size();
        root.getChildren().add(size - 1, chip);
    }
1061445
public static String getStackTrace(Throwable ex) {
        StringWriter buf = new StringWriter();
        ex.printStackTrace(new PrintWriter(buf));

        return buf.toString();
    }
1074031
public String getStack() {
		if (stackTrace == null) {
			if (stack == null) {
				StringWriter sw = new StringWriter(512);
				PrintWriter pw = new PrintWriter(sw, true);
				super.printStackTrace(pw);
				stackTrace = sw.toString().trim();
			} else {
				stackTrace = stack.trim();
			}
		}
		return stackTrace;
	}
680730
public static <T extends Output<T>> Feeder<T> createFeeder(T output) {
    return new Feeder<T>(output);
  }
1114005
private String getStackTrace(AbstractEngineException data) {
        try (StringBuilderWriter writer = new StringBuilderWriter()) {
            data.printStackTrace(new PrintWriter(writer));
            return writer.getBuilder().toString();
        }
    }
479548
public static void writeResults(final String name, final Object output) {
		Writer writer = null;

		try {
			writer = new BufferedWriter(
					new OutputStreamWriter(
					new FileOutputStream(name + ".json"), "utf-8"));

			writer.write(output.toString());
		} catch (IOException ignored) {
		} finally {
			try {writer.close();}
            catch (Exception ignored) {}
		}
	}
304797
private <T> T getItem(String itemName, Map<String, T> items, String typeName) {
		T item = items.get(itemName);
		if (item == null) {
			throw new FuzzerException(name + ": " + typeName + " '" + itemName + "' not found");
		}
		return item;
	}
562079
public <T> T output(@NonNull ModelAdapter<T> adapter, INDArray... inputs) {
        return output(adapter, inputs, null);
    }
52427
@Override
    public java.util.concurrent.Future<PutItemResult> putItemAsync(String tableName, java.util.Map<String, AttributeValue> item,
            com.amazonaws.handlers.AsyncHandler<PutItemRequest, PutItemResult> asyncHandler) {

        return putItemAsync(new PutItemRequest().withTableName(tableName).withItem(item), asyncHandler);
    }
912004
public static StringBuilder createStackTrace(StringBuilder s, StackTraceElement[] stack) {
		if (stack != null)
			for (StackTraceElement e : stack) {
				s.append("\n\tat ");
				s.append(e.getClassName());
				if (e.getMethodName() != null) {
					s.append('.');
					s.append(e.getMethodName());
				}
				if (e.getFileName() != null) {
					s.append('(');
					s.append(e.getFileName());
					s.append(':');
					s.append(e.getLineNumber());
					s.append(')');
				}
			}
		return s;
	}
672502
public static void dumpAll(Iterator<? extends Object> data, Writer output) {
    getSnakeYaml().dumpAll(data, output);
  }
245892
public static String getStackTrace(final Throwable ex) {
        final StringWriter sw = new StringWriter();
        final PrintWriter pw = new PrintWriter(sw, true);
        ex.printStackTrace(pw);
        pw.flush();
        sw.flush();
        return sw.toString();
    }
343437
private static StackLine getStackLine(SrcTree srcTree,
            String classQualifiedName, String methodSimpleName, int line) {
        StackLine rootStackLine = getStackLine(
                srcTree.getRootMethodTable(), classQualifiedName, methodSimpleName, line);
        if (rootStackLine != null) {
            return rootStackLine;
        }
        StackLine subStackLine = getStackLine(
                srcTree.getSubMethodTable(), classQualifiedName, methodSimpleName, line);
        if (subStackLine != null) {
            return subStackLine;
        }
        return null;
    }