return as(type, tagged.getBaseObject());
    }

    /**
     * Gets an element from a DLSequence at the specified index and casts it to the specified type
     * @param <T> the target ASN.1 primitive type
     * @param type the target class type
     * @param sequence the DLSequence
     * @param index the element index
     * @return sequence element cast to type
     * @throws PACDecodingException if types are incompatible
     */

   * insertion order.
   */
  private void populateTShapedGraph() {
    putEdge(2, 1);
    putEdge(1, 4);
    putEdge(1, 3);
    putEdge(1, 2); // Duplicate
    putEdge(4, 5);
  }

  // Element Mutation

  @Test
  public void putEdge_existingNodes() {
    assume().that(graphIsMutable()).isTrue();

    // Adding nodes initially for safety (insulating from possible future

    @Override
    public boolean add(final Map<String, Object> e) {
        return parent.add(e);
    }

    @Override
    public void add(final int index, final Map<String, Object> element) {
        parent.add(index, element);
    }

    @Override
    public boolean addAll(final Collection<? extends Map<String, Object>> c) {
        return parent.addAll(c);
    }

    @Override

  @Override
  void setCountCheckReturnValue(E element, int count) {
    assertEquals(
        "multiset.setCount() should return the old count",
        getMultiset().count(element),
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private int setCount(E element, int count) {

        for (final int[] element : DOS_ERROR_CODES) {
            dosErrorCodeStatusesTmp.put(element[0], element[1]);
            final int mappedNtCode = element[1];
            final String mappedNtMessage = errorCodeMessagesTmp.get(mappedNtCode);
            if (mappedNtMessage != null) {
                errorCodeMessagesTmp.put(element[0], mappedNtMessage);
            }
        }

    @Override
    public boolean contains(@Nullable Object object) {
      return containsKey(object);
    }

    @Override
    public int count(@Nullable Object element) {
      Collection<V> values = map.get(element);
      return (values == null) ? 0 : values.size();
    }

    @Override
    public ImmutableSet<K> elementSet() {
      return keySet();
    }

    @Override

 */
final class SingletonImmutableSet<E> extends ImmutableSet<E> {
  private final E element;

  SingletonImmutableSet(E element) {
    this.element = checkNotNull(element);
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return Iterators.singletonIterator(element);
  }

  @Override
  public boolean contains(@Nullable Object object) {

        C filtered = filter(unfiltered, EVEN);
        List<Integer> foundElements = new ArrayList<>();
        filtered.forEach(
            (Integer i) -> {
              assertTrue("Unexpected element: " + i, EVEN.apply(i));
              foundElements.add(i);
            });
        assertEquals(ImmutableList.copyOf(filtered), foundElements);
      }
    }
  }

        return;
      }

      Document document = Jsoup.parse(response.body().string(), url.toString());
      for (Element element : document.select("a[href]")) {
        String href = element.attr("href");
        HttpUrl link = response.request().url().resolve(href);
        if (link == null) continue; // URL is either invalid or its scheme isn't http/https.

            <p><b>Note:</b> This will not automagically make a Mojo run when the plugin declaration is added
            to the POM. It merely enables the user to omit the {@code <phase>} element from the
            surrounding {@code <execution>} element.</p>
          </description>
        </field>
        <field>
          <name>executePhase</name>
          <version>1.0.0+</version>
          <type>String</type>