} catch (final InstantiationException e) {
            throw new InstantiationRuntimeException(constructor.getDeclaringClass(), e);
        } catch (final IllegalAccessException e) {
            throw new IllegalAccessRuntimeException(constructor.getDeclaringClass(), e);
        } catch (final InvocationTargetException e) {
            throw new InvocationTargetRuntimeException(constructor.getDeclaringClass(), e);
        }
    }

    extends AbstractMapBasedMultiset<E> {

  /** Creates a new, empty {@code LinkedHashMultiset} using the default initial capacity. */
  public static <E extends @Nullable Object> LinkedHashMultiset<E> create() {
    return create(ObjectCountHashMap.DEFAULT_SIZE);
  }

  /**
   * Creates a new, empty {@code LinkedHashMultiset} with the specified expected number of distinct
   * elements.
   *

    }

    RtmSession rtmSession = new RtmSession(slackApi);
    rtmSession.open(accessToken);
  }

  public static void main(String... args) throws Exception {
    String clientId = "0000000000.00000000000";
    String clientSecret = "00000000000000000000000000000000";
    int port = 53203;
    SlackApi slackApi = new SlackApi(clientId, clientSecret, port);

    SlackClient client = new SlackClient(slackApi);

    @Override
    public QName getName() {
        return new QName(null, node.name());
    }

    @Override
    public boolean isCollection() {
        return false;
    }

    @Override
    public boolean isLeaf() {
        return node.children().isEmpty();
    }

    @Override
    public void setValue(Object value) {
        throw new UnsupportedOperationException();
    }

    @Override

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance()
        factory.setNamespaceAware(true)
        DocumentBuilder builder = factory.newDocumentBuilder()
        def parsed = builder.parse(new InputSource(new StringReader(str))).documentElement
        return document ? document.importNode(parsed, true) : parsed
    }

    def formatTree(Closure cl) {
        withCategories {
            return formatTree(cl.call())

    @Test
    public void testMultipleConverterInstances() throws IOException {
        // Test that multiple converter instances work independently
        AnalyzerConverter converter1 = new AnalyzerConverter(client, settings);
        AnalyzerConverter converter2 = new AnalyzerConverter(client, settings);

        String text = "test";
        String field = "content";

        List<String> results1 = converter1.convert(text, field, "en");

                logger.debug(e.getMessage(), e);
            }
        }

        PluginPrefixRequest prefixRequest = new DefaultPluginPrefixRequest(prefix, session);
        PluginPrefixResult prefixResult = pluginPrefixResolver.resolve(prefixRequest);

        Plugin plugin = new Plugin();
        plugin.setGroupId(prefixResult.getGroupId());
        plugin.setArtifactId(prefixResult.getArtifactId());

            return getGraph();
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.versionedGraph)) {
            return new MetadataGraph(getTree(), true, false);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.scopedGraph)) {
            return new MetadataGraph(getTree(), true, true);
        }
        return null;
    }

    /**
     * The collection of problems associated with this exception.
     */
    private final ProblemCollector<BuilderProblem> problems;

    /**
     * Constructs a new exception with the specified message and cause.
     * This constructor creates an empty problem collector.
     *
     * @param message the detail message
     * @param cause the cause of this exception
     */

            return new MavenStaxReader().read(is, false, null);
        }
    }

    protected void write(Model model, Path dest) throws IOException, XMLStreamException {
        String version = model.getModelVersion();
        Files.createDirectories(dest.getParent());
        try (Writer w = Files.newBufferedWriter(dest)) {
            MavenStaxWriter writer = new MavenStaxWriter();